Description

给出一个N个点的无根无向树
求合法的路径条数
一个路径合法，当且仅当路径上不存在任何一对点编号为(x,y)，使得gcd(x,y)=x
n<=1e5

Solution

不妨枚举每个点，枚举它的倍数编号的点，显然这样是Nlog N的

随便定一个根
假设枚举出来两个点x，kx
如果lca(x,kx)不是这两个之一，那么x的子树和kx的子树不能互相到达

可以建立一个平面直角坐标系，点（x,y）表示x不能到y

因为子树的DFS序是连续的，投到平面直角坐标系上就是一个矩形。

同理讨论lca(x,kx)是这两个之一（也就是其中一个是另一个祖先）
那么可以投出两个巨型。
扫描线维护矩形的交即可。
矩形应当按照一定的方向，比如说小的不能到打的

Code

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
#define LL long long
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fod(i,a,b) for(int i=a;i>=b;i--)
#define N 100005
using namespace std;
int n,a[N][2],fs[N],nt[2*N],dt[2*N],ans,m,lf[N],rf[N],fa[N][20],dep[N],num,dfn,n1;
struct node
{
    int l,r,x,v;
}sq[50*N];
struct nd
{
    int l,r,v,s;
}tr[50*N];
void link(int x,int y)
{
    nt[++m]=fs[x];
    dt[fs[x]=m]=y;
}
void dfs(int k,int f)
{
    lf[k]=rf[k]=++dfn;
    dep[k]=dep[f]+1;
    fa[k][0]=f;
    for(int i=fs[k];i;i=nt[i])
    {
        int p=dt[i];
        if(p==f) continue;
        dfs(p,k);
        rf[k]=max(rf[k],rf[p]);
    }
}
void put(int l,int r,int x,int y)
{
    if(l<x) swap(l,x),swap(r,y);
    if(l>r||x>y) return;
    sq[++num].x=l,sq[num].l=x,sq[num].r=y,sq[num].v=1;
    sq[++num].x=r+1,sq[num].l=x,sq[num].r=y,sq[num].v=-1;
}
bool cmp(node x,node y)
{
    return(x.x<y.x||(x.x==y.x&&x.v>y.v));
}
int lca(int x,int y)
{
    if(dep[x]>dep[y]) swap(x,y);
    int j=16;
    while(dep[x]<dep[y])
    {
        while(j>0&&dep[fa[y][j]]<dep[x]) j--;
        y=fa[y][j];
    }
    j=16;
    while(x!=y)
    {
        while(j>0&&fa[y][j]==fa[x][j])j--;
        x=fa[x][j],y=fa[y][j];
    }
    return x;
}
int jump(int y,int x)
{
    int j=16;
    while(dep[y]>dep[x]+1)
    {
        while(j>0&&dep[fa[y][j]]<dep[x]+1) j--;
        y=fa[y][j];
    }
    return y;
}
void up(int k)
{
    tr[k].s=tr[tr[k].l].s+tr[tr[k].r].s;
}
void nwp(int k,int p)
{
    if(p==0) tr[k].l=++n1,tr[n1].s=tr[n1].v=0;
    else tr[k].r=++n1,tr[n1].s=tr[n1].v=0;
}
void ins(int k,int l,int r,int x,int y,int v)
{
    if(l==x&&r==y) 
    {
        tr[k].v+=v;
        if(tr[k].v==0) tr[k].s=0,up(k);
        else tr[k].s=(r-l+1);
        return;
    }
    int mid=(l+r)/2;
    if(tr[k].l==0) nwp(k,0);
    if(tr[k].r==0) nwp(k,1);
    if(y<=mid) ins(tr[k].l,l,mid,x,y,v);
    else if(x>mid) ins(tr[k].r,mid+1,r,x,y,v);
    else ins(tr[k].l,l,mid,x,mid,v),ins(tr[k].r,mid+1,r,mid+1,y,v);
    if(tr[k].v==0) up(k);
    else tr[k].s=r-l+1;
}
int main()
{
    cin>>n;
    fo(i,1,n-1) 
    {
        int x,y;
        scanf("%d%d",&x,&y);
        link(x,y),link(y,x);
    }
    n1=0;
    dfn=0;
    dfs(1,0);
    LL ans=(LL)n*((LL)n-1)/2;
    fo(i,1,16) 
        fo(k,1,n) fa[k][i]=fa[fa[k][i-1]][i-1];
    fo(i,1,n)
    {
        fo(j,2,n/i)
        {
            int x=i,y=i*j;
            if(dep[x]>dep[y]) swap(x,y);
            if(lca(x,y)==x) 
            {
                int p=jump(y,x);
                put(1,lf[p]-1,lf[y],rf[y]);
                put(lf[y],rf[y],rf[p]+1,n);
            }
            else put(lf[x],rf[x],lf[y],rf[y]);
        }
    }
    sort(sq+1,sq+num+1,cmp);
    int ls=0;
    n1=1;
    fo(i,1,num)
    {
        ans-=(LL)tr[1].s*(sq[i].x-ls);
        ins(1,1,n,sq[i].l,sq[i].r,sq[i].v);
        ls=sq[i].x;
    }
    printf("%lld",ans);
}