树上邻域数点 树分块长剖题解。

设常数 $b$，考虑将邻域分为 $[b^i,b^{i+1})$ 的一些块。对于所有的 $[b^i,b^{i+1})$，我们将整棵树按照 $b^i$ 分块来处理所有大小在这个区间中的邻域。

我们发现，这个区间中的所有邻域大小都 $\geq b^i$，所以一定完全覆盖了邻域中心所在的块。所以我们把这一整个块和上界点的一个外邻域和下界点的一个内邻域 Compress 起来即可。

为了求这两个东西，我们考虑先求出每个块中上界点和下界点在簇内的所有大小的邻域，然后再在收缩树上换根 dp 求出上述两个东西。

为了求前者，我们考虑长剖。对于每个节点我们维护两个序列：一个差分 tag 序列和一个真实值序列（称为 $A$ 和 $B$）。对于 dp 序列中的一个位置 $i$，其真实值为 $C(B_i,C(A_0,C(A_1,C(A_2,C(\dots A_i)))))$。考虑合并长儿子和一个短儿子：设短儿子高度为 $h$，对于前 $h$ 项，我们求出两个儿子分别的真实值然后 Rake 起来。对于后面的部分，我们把长儿子的 $A$ 序列前 $h+1$ 项 Compress 起来，然后再 Rake 上短儿子整体的真实值。

这样我们就几乎做完了。但是这个做法有两个问题。第一个是，我们希望我们得到的簇的两个界点正好是当前块的两个界点（要不然没法跟簇外面的东西合并）。我们把一个界点作为根的时候，实际上的另一个界点是其所在长链链底。所以，我们强制把簇路径设为根节点所在长链；这部分合并的时候要先补齐到真实长链的高度。同时，对于当前块的另一个界点子树内，我们将这部分信息整体 Rake 到其和其父亲的边上。这样就能保证另一个界点就在这个点上了。

第二个问题是，我们在处理第 $h+1$ 项时，如果本来长儿子前 $h+1$ 项都是 empty，那处理过后这一个位置的 $A$ 值的另一个界点就会变成短儿子子树内的点。所以我们把 tag 分为两种，Compress Tag 和 Rake Tag。如果发生了这种情况，我们就在这个位置上打一个短儿子的 Rake Tag。在获取真实值，也就是把 Tag “往前推”的过程中，如果遇到一个 Rake Tag，就把他和当前的真实值 Rake 起来并且复制到下一个位置。如果下一个位置已经有 Compress Tag，那么直接把这两个 Tag Rake 起来即可。

长剖部分就到此结束了。然后我们在收缩树上换根 dp，将每个簇内部的邻域和收缩树上这个方向上所有儿子的 dp 值 Rake 后 Compress 起来即可。这样每次查询的时候需要 Compress 两次，所以我们把内邻域的 dp 值提前和整个块合并一下，就只需要一次了。

此时取 $b\in[3,3.2]$ 是比较优的，可以获得 90 分，无法通过最后两个测试点。不过我们发现，所有的内邻域不需要经过值域分块后长剖，而可以先记录下来然后在一开始用一个整棵树的大长剖 dp 求出来。这样可以削掉很多合并次数。同时注意在实现的时候不要重复进行很多本质相同的合并（例如目前需要合并的深度已经超过了子树深度）。此时的总操作次数大概在两千八百万，可以通过。

代码实现比较平凡：

#pragma GCC optimize("Ofast","inline","unroll-loops")
#include "count.h"
#include<bits/stdc++.h>
using namespace std;
#define endl '\n'
const int N=200009,LG=20;
// void print(info x){
//     cout<<x.vertex[0]<<' '<<x.vertex[1]<<endl;
// }

mt19937 rnd(time(NULL));
int qoo=0;
info qMR(info x,info y){
    return isempty(x)?y:isempty(y)?x:(++qoo,MR(x,y));
}
info qMC(info x,info y){
    return isempty(x)?y:isempty(y)?x:(++qoo,MC(x,y));
}

int n,q,fa[N];
info a[N];

int ftop[LG],uc[LG][N],dc[LG][N],bel[LG][N],ufa[LG][N],clen[LG][N],disu[LG][N][2];
int mxd[N];
vector<info> pi[LG][N][2],po[LG][N][2],tg[N],ori[N],ftmp[N],prf[N],suf[N],ot[LG][N];
int ndf[N],pndf[N],sndf[N];
vector<bool> typ[N];
vector<array<int,2> > g2[LG][N];
bool isn[LG][N],isp[LG][N];

int ed[N],etop,esz[N],eld[N],ecut[N];

vector<int> g[N],sn[N],neb[LG][N][2];
void pck(int u,int w,int &piv,int R,int B,int id){
    isn[id][u]=isn[id][w]=1;
    ufa[id][w]=u;
    g2[id][u].push_back({w,ftop[id]});
    g2[id][w].push_back({u,ftop[id]});
    uc[id][ftop[id]]=u;
    dc[id][ftop[id]]=w;
    clen[id][ftop[id]]=0;
    for(int p=w;p!=u;p=fa[p])isp[id][p]=1,clen[id][ftop[id]]++;
    isp[id][u]=isp[id][w]=1;
    while(piv<=R){
        int c=ed[piv];
        if(c!=u)bel[id][c]=ftop[id];
        piv++;
    }
    bel[id][w]=ftop[id];
}
int gleaf(int u){
    return (int)sn[u].empty()?u:gleaf(sn[u][0]);
}
void ecl(int u,int B,int id){
    esz[u]=0;ecut[u]=etop;
    int nid=0;
    for(int v:sn[u]){
        ed[++etop]=v;
        ecl(v,B,id);
        esz[u]+=esz[v]+1;
        if(eld[v])eld[u]=eld[v],nid++;
    }
    if(nid>1||u==n||esz[u]>=B){
        esz[u]=0;eld[u]=u;
        int cur=0,cnid=0,sid=ecut[u]+1;
        for(int v:sn[u]){
            if(cur+esz[v]+1>B||cnid&&eld[v]){
                ftop[id]++;
                pck(u,cnid?cnid:gleaf(ed[sid]),sid,ecut[v]-1,B,id);
                cur=cnid=0;
            }
            cur+=esz[v]+1;if(eld[v])cnid=eld[v];
        }
        ftop[id]++;
        pck(u,cnid?cnid:gleaf(ed[sid]),sid,etop,B,id);
        etop=ecut[u];
    }
}

info get(int u,int v){
    return fa[u]==v?a[u]:a[v];
}
bool ck(int u,int id,int cid){
    return bel[id][u]==cid||u==uc[id][cid]||u==dc[id][cid];
}
void NR(int u,int id,info x){
    if(!id)return ori[u][id]=qMR(qMC(ori[u][id],tg[u][id]),x),tg[u][id]=emptyinfo,void();
    if(!typ[u][id]&&isempty(tg[u][id]))typ[u][id]=1;
    tg[u][id]=qMR(tg[u][id],x);
}
void pusht(int u,int id){
    assert(id>=0&&id<(int)tg[u].size());
    if(typ[u][id]){
        ori[u][id]=qMR(ori[u][id],tg[u][id]);
        if(id)NR(u,id-1,tg[u][id]);
        tg[u][id]=emptyinfo;
        typ[u][id]=0;
    }
}
void rel(int u,int sz=-1){
    if(sz<0)sz=(int)tg[u].size();
    else sz=min(sz,(int)tg[u].size());
    info cur=emptyinfo;
    for(int i=(int)tg[u].size()-1;i>=(int)tg[u].size()-sz;i--)
        pusht(u,i),cur=qMC(cur,tg[u][i]),ori[u][i]=qMC(ori[u][i],cur),tg[u][i]=emptyinfo;
    if(sz<(int)tg[u].size()){
        pusht(u,(int)tg[u].size()-sz-1);
        tg[u][(int)tg[u].size()-sz-1]=qMC(tg[u][(int)tg[u].size()-sz-1],cur);
    }
}
void clr(int u,int f,int id,int cid){
    tg[u].clear();ori[u].clear();
    tg[u].shrink_to_fit();
    ori[u].shrink_to_fit();
    mxd[u]=0;
    vector<int> vec;
    if(u==uc[id][cid])vec=neb[id][cid][0];
    else if(u==dc[id][cid])vec=neb[id][cid][1];
    else vec=g[u];
    for(int v:vec)if(v!=f&&ck(v,id,cid))clr(v,u,id,cid);
}
int dism,mxx[N];
void dfs(int u,int f,int id,int cid,bool op=0){
    vector<int> vec;
    if(u==uc[id][cid])vec=neb[id][cid][0];
    else if(u==dc[id][cid])vec=neb[id][cid][1];
    else vec=g[u];
    if(op)vec=g[u];
    tg[u].clear();ori[u].clear();typ[u].clear();
    int son=0;mxd[u]=0;
    for(int v:vec)if(v!=f&&(ck(v,id,cid)||op)){
        dfs(v,u,id,cid,op);
        mxd[u]=max(mxd[u],mxd[v]+1);
        if(!son||mxd[son]<mxd[v])son=v;
    }
    if(!son){
        tg[u].push_back(emptyinfo),ori[u].push_back(emptyinfo),typ[u].push_back(false);
        if(op){
            rel(u,ndf[u]);
            for(int i=0;i<ndf[u];i++)
                ftmp[u].push_back(ori[u][max(0,(int)ori[u].size()-1-i)]);
        }
        return ;
    }
    if(!op)for(int v:vec)if(v!=f&&ck(v,id,cid))
        if(isp[id][v])son=v;
    if(op){
        int cc=0;
        for(int v:sn[u])cc=max(cc,pndf[v]),tg[v].back()=get(u,v);
        for(int v:sn[u])mxx[v]=0;
        reverse(sn[u].begin(),sn[u].end());
        int tmx=0;
        for(int v:sn[u]){
            mxx[v]=tmx;
            tmx=max(tmx,pndf[v]);
        }
        reverse(sn[u].begin(),sn[u].end());
        vector<info> tmp(cc,emptyinfo),ttg(cc,emptyinfo);
        for(int v:sn[u]){
            int sz=(int)ori[v].size();
            for(int p=0;p<min(cc,max(pndf[v],sz));p++){
                if(p+1<cc)ttg[p+1]=qMR(ttg[p+1],ttg[p]);
                tmp[p]=qMR(tmp[p],ttg[p]);
                ttg[p]=emptyinfo;
            }
            for(int p=0;p<pndf[v];p++)assert(isempty(ttg[p]));
            for(int p=0;p<pndf[v];p++)prf[v].push_back(tmp[p]);
            rel(v,max(0,mxx[v]-1));
            for(int i=1;i<mxx[v]&&i<sz;i++){
                if(i>mxd[u]){
                    tmp[i]=tmp[i-1];
                    continue;
                }
                tmp[i]=qMR(tmp[i],ori[v][max(0,sz-i)]);
            }
            if(sz<mxx[v])ttg[sz]=qMR(ttg[sz],ori[v][0]);
        }
        reverse(sn[u].begin(),sn[u].end());
        for(int v:sn[u])mxx[v]=0;
        reverse(sn[u].begin(),sn[u].end());
        tmx=0;
        for(int v:sn[u]){
            mxx[v]=tmx;
            tmx=max(tmx,sndf[v]);
        }
        reverse(sn[u].begin(),sn[u].end());
        vector<info> tmp2(cc,emptyinfo),tg2(cc,emptyinfo);
        for(int v:sn[u]){
            int sz=(int)ori[v].size();
            for(int p=0;p<min(cc,max(sndf[v],sz));p++){
                if(p+1<cc)tg2[p+1]=qMR(tg2[p+1],tg2[p]);
                tmp2[p]=qMR(tmp2[p],tg2[p]);
                tg2[p]=emptyinfo;
            }
            for(int p=0;p<sndf[v];p++)suf[v].push_back(tmp2[p]);
            rel(v,max(0,mxx[v]-1));
            for(int i=1;i<mxx[v]&&i<sz;i++){
                if(i>mxd[u]){
                    tmp2[i]=tmp2[i-1];
                    continue;
                }
                tmp2[i]=qMR(tmp2[i],ori[v][max(0,sz-i)]);
            }
            if(sz<mxx[v])tg2[sz]=qMR(tg2[sz],ori[v][0]);
        }
        reverse(sn[u].begin(),sn[u].end());
    }
    swap(tg[u],tg[son]);
    swap(ori[u],ori[son]);
    swap(typ[u],typ[son]);
    if(!op){
        if(son==dism){
            rel(u);
            for(auto &p:ori[u])p=qMR(get(u,son),p);
        }else tg[u].back()=get(u,son);
        if((int)tg[u].size()<mxd[u]){
            vector<bool> ttyp(mxd[u]-(int)typ[u].size(),false);
            swap(ttyp,typ[u]);for(auto x:ttyp)typ[u].push_back(x);
            vector<info> tmp(mxd[u]-(int)tg[u].size(),emptyinfo);
            swap(tmp,tg[u]);for(auto x:tmp)tg[u].push_back(x);
            vector<info> tmp2(mxd[u]-(int)ori[u].size(),ori[u][0]);
            swap(tmp2,ori[u]);for(auto x:tmp2)ori[u].push_back(x);
        }
    }
    for(int v:vec)if(v!=f&&(ck(v,id,cid)||op)&&v!=son){
        if(!op)tg[v].back()=get(u,v);
        rel(v);
        int szu=(int)tg[u].size(),szv=(int)tg[v].size();
        info cur=emptyinfo,cvr=emptyinfo;
        for(int i=0;i<szv;i++){
            pusht(u,szu-1-i);
            cur=qMC(cur,tg[u][szu-1-i]);
            cvr=ori[v][szv-1-i];
            tg[u][szu-1-i]=emptyinfo;
            ori[u][szu-1-i]=qMR(qMC(ori[u][szu-1-i],cur),cvr);
        }
        if(szu>szv){
            pusht(u,szu-1-szv);
            tg[u][szu-1-szv]=qMC(tg[u][szu-1-szv],cur);
            NR(u,szu-1-szv,cvr);
        }
        tg[v].clear();ori[v].clear();
    }
    tg[u].push_back(emptyinfo),ori[u].push_back(emptyinfo),typ[u].push_back(false);
    if(op){
        rel(u,ndf[u]);
        for(int i=0;i<ndf[u];i++)
            ftmp[u].push_back(ori[u][max(0,(int)ori[u].size()-1-i)]);
    }
    // cout<<u<<' '<<ndf[u]<<' '<<ftmp[u].size()<<endl;
}
bool ckd[N];
bool fd[N][2];
int itt[N],ott[N],tmpmx[LG][N];
int itmpmx[N];
void cck(int u,int f){
    if(fa[u]==f){
        if(fd[u][0])return ;
        fd[u][0]=1;
    }else{
        if(fd[f][1])return ;
        fd[f][1]=1;
    }
    if(fa[u]==f){
        int mx=0;
        for(int v:g[u])if(v!=f){
            cck(v,u);
            mx=max(mx,itt[v]+1);
        }
        itt[u]=mx;
        multiset<int> s;
        for(int v:g[u])if(v!=f)s.insert(itt[v]+1);
        for(int v:g[u])if(v!=f){
            s.erase(s.find(itt[v]+1));
            itmpmx[v]=s.empty()?1:*s.rbegin();
            s.insert(itt[v]+1);
        }
    }else{
        int mx=itmpmx[f];
        if(fa[u])cck(fa[u],u),mx=max(mx,ott[u]+1);
        ott[f]=mx;
    }
}
bool dlvis[LG][N];
void dfs2(int id,int B,int u){
    if(ckd[u])return ;
    ckd[u]=1;
    po[id][u][1].clear();
    for(int i=0;i<B;i++)po[id][u][1].push_back(ot[id][u][i]);
    int y=uc[id][u],x=dc[id][u];
    vector<array<int,2> > tmp2={};
    for(auto p:g2[id][y]){
        int v=p[0];
        if(v!=x){
            int idc=(uc[id][p[1]]==v);
            if(!idc)continue;
            if(!dlvis[id][y])tmp2.push_back(p);
            dfs2(id,B,p[1]);
            for(int i=0;i<B;i++){
                if(i>max(ott[y],tmpmx[id][u])+1){
                    po[id][u][1][i]=po[id][u][1][i-1];
                    continue;
                }
                if(i<=clen[id][p[1]])
                    po[id][u][1][i]=qMR(po[id][u][1][i],
                    pi[id][p[1]][1][max((int)pi[id][p[1]][1].size()-1-i,0)]);
                else
                    po[id][u][1][i]=qMR(po[id][u][1][i],
                    qMC(pi[id][p[1]][1][max((int)pi[id][p[1]][1].size()-1-i,0)],
                    po[id][p[1]][1][i-clen[id][p[1]]]));
                // if(i&&po[id][u][op][i]==po[id][u][op][i-1]){
                //     for(int j=i;j<B;j++)po[id][u][op][j]=po[id][u][op][j-1];
                //     break;
                // }
            }
        }
    }
    if(!dlvis[id][y])g2[id][y]=tmp2;
    dlvis[id][y]=1;
}
void cd(int u,int f,int di,int id,int cid,int op){
    vector<int> vec;
    if(u==uc[id][cid])vec=neb[id][cid][0];
    else if(u==dc[id][cid])vec=neb[id][cid][1];
    else vec=g[u];
    disu[id][u][op]=di;
    for(int v:vec)if(v!=f&&ck(v,id,cid))
        cd(v,u,di+1,id,cid,op);
}
const int S=3;
int pw[25];
bool tvis[N];
int pp[N];
void init(int caso,int _n,int _q,vector<int> _fa,vector<info> _e,int M){
    n=_n;q=_q;for(int i=2;i<=n;i++)fa[i]=_fa[i-2];
    for(int i=2;i<=n;i++)a[i]=_e[i-2];
    for(int i=2;i<=n;i++)g[fa[i]].push_back(i);
    for(int i=2;i<=n;i++)g[i].push_back(fa[i]);
    if(n==1)return ;
    ++n;fa[1]=n;g[1].push_back(n);g[n].push_back(1);a[1]=emptyinfo;
    pw[0]=1;pw[1]=5;
    for(int i=2;i<=LG;i++)pw[i]=pw[i-1]*S;
    for(int i=1;i<=n;i++)cck(i,fa[i]);
    for(int i=1;i<=n;i++)cck(fa[i],i);
    // for(int i=1;i<=n;i++)shuffle(g[i].begin(),g[i].end(),rnd);
    for(int i=1;i<=n;i++)sn[i]=g[i];
    for(int i=1;i<n;i++)sn[i].erase(find(sn[i].begin(),sn[i].end(),fa[i]));
    int __TOT=0;
    for(int w=0;pw[w]<=n;w++){
        etop=0;
        memset(ed,0,sizeof(int)*(n+5));
        memset(esz,0,sizeof(int)*(n+5));
        memset(eld,0,sizeof(int)*(n+5));
        memset(ecut,0,sizeof(int)*(n+5));
        ecl(n,pw[w],w);
        for(int i=1;i<=n;i++)if(isn[w][i])
            ndf[i]=min(n,pw[w+1]);
        memset(tvis,0,sizeof(tvis));
        for(int i=1;i<=ftop[w];i++)if(!tvis[uc[w][i]]){
            int u=uc[w][i];
            tvis[u]=1;
            int dmx=0;
            for(int j=0,nj;j<(int)sn[u].size();j=nj+1){
                nj=j;while(nj+1<(int)sn[u].size()&&bel[w][sn[u][nj]]==bel[w][sn[u][nj+1]])nj++;
                __TOT+=min(n,pw[w+1]);
                pndf[sn[u][j]]=min(n,pw[w+1]);
                sndf[sn[u][nj]]=min(n,pw[w+1]);
                tmpmx[w][bel[w][sn[u][j]]]=max(tmpmx[w][bel[w][sn[u][j]]],dmx);
                for(int p=j;p<=nj;p++)
                    pp[sn[u][p]]=min(n,pw[w+1]),dmx=max(dmx,itt[sn[u][p]]);
            }
            reverse(sn[u].begin(),sn[u].end());
            dmx=0;
            for(int j=0,nj;j<(int)sn[u].size();j=nj+1){
                nj=j;while(nj+1<(int)sn[u].size()&&bel[w][sn[u][nj]]==bel[w][sn[u][nj+1]])nj++;
                tmpmx[w][bel[w][sn[u][j]]]=max(tmpmx[w][bel[w][sn[u][j]]],dmx);
                for(int p=j;p<=nj;p++)
                    dmx=max(dmx,itt[sn[u][p]]);
            }
            reverse(sn[u].begin(),sn[u].end());
        }
        for(int i=1;i<=n;i++)for(int j:g[i]){
            int id=(fa[i]==j?bel[w][i]:bel[w][j]);
            if(i==uc[w][id])neb[w][id][0].push_back(j);
            else if(i==dc[w][id])neb[w][id][1].push_back(j);
        }
    }
    cerr<<__TOT<<endl;
    for(int i=1;i<=n;i++)
        stable_sort(sn[i].begin(),sn[i].end(),[&](int x,int y){
            return pp[x]<pp[y];
        });
    dfs(n,0,0,0,1);
    for(int w=0;pw[w]<=n;w++){
        memset(tvis,0,sizeof(tvis));
        for(int i=1;i<=ftop[w];i++)if(!tvis[uc[w][i]]){
            int u=uc[w][i];tvis[u]=1;
            for(int j=0,nj;j<(int)sn[u].size();j=nj+1){
                nj=j;while(nj+1<(int)sn[u].size()&&bel[w][sn[u][nj]]==bel[w][sn[u][nj+1]])nj++;
                int v1=sn[u][j],v2=sn[u][nj];
                for(int p=0;p<pw[w+1];p++){
                    // if(p>=2&&ot[w][bel[w][v1]][p-1]==ot[w][bel[w][v1]][p-2]){
                    //     ot[w][bel[w][v1]].push_back(ot[w][bel[w][v1]].back());
                    //     continue;
                    // }
                    ot[w][bel[w][v1]].push_back(qMR(prf[v1][min(p,n-1)],suf[v2][min(p,n-1)]));
                }
            }
        }
    }
    // for(int i=1;i<=n;i++)cout<<ndf[i]<<' '<<ftmp[i].size()<<endl;
    // exit(0);
    for(int w=0;pw[w]<=n;w++){
        for(int i=1;i<=ftop[w];i++){
            int u=uc[w][i],v=dc[w][i];
            // cout<<u<<' '<<v<<endl;
            cd(u,0,0,w,i,0);
            cd(v,0,0,w,i,1);
            clr(u,0,w,i);
            // dism=v;dfs(u,0,w,i);
            // rel(u);
            // pi[w][i][0]=ori[u];
            clr(v,0,w,i);
            dism=u;dfs(v,0,w,i);
            rel(v);
            pi[w][i][1]=ori[v];
        }
        memset(ckd,0,sizeof(ckd));
        for(int i=1;i<=ftop[w];i++){
            for(int j=0;j<pw[w+1];j++)
                po[w][i][0].push_back(ftmp[dc[w][i]][min(n-1,j)]);
            // dfs2(w,2<<w,i,0);
        }
        for(int i=1;i<=ftop[w];i++)
            dfs2(w,pw[w+1],i);
        for(int i=1;i<=ftop[w];i++)
            for(int j=0;j<pw[w+1];j++)
                po[w][i][0][j]=qMC(po[w][i][0][j],pi[w][i][1][0]);
    }
    cerr<<qoo<<endl;
    for(int w=0;pw[w]<=n;w++)
        cerr<<pw[w]*ftop[w]<<endl;
}
info ask(int u,int d){
    if(n==1)return emptyinfo;
    if(!d)return emptyinfo;
    int id=0;while(pw[id+1]<=d)id++;
    if(!isn[id][u])
        return qMC(po[id][bel[id][u]][0][d-disu[id][u][1]],
        po[id][bel[id][u]][1][d-disu[id][u][0]]);
    else 
        return qMC(po[id][bel[id][u]][0][d],
        po[id][bel[id][u]][1][d-clen[id][bel[id][u]]]);
}