CF1009F Dominant Indices(树上DSU/长链剖分)

题目大意：

就是给你一棵以1为根的树，询问每一个节点的子树内节点数最多的深度（相对于这个子树根而言）若有多解，输出最小的。

解题思路：

这道题用树链剖分，两种思路：

1.树上DSU

首先想一下最暴力的算法：统计子树每个深度节点的个数（桶）相当于以每个节点为根遍历子树搜索一遍答案，这样做时间复杂度是O(n²)，显然过不去。

考虑一下优化。假如说我们模拟一下搜索答案的过程，我们发现在每一次暴搜时都会在桶中添加一些答案。而这些答案的整体只会对该节点及其祖先产生贡献，也就是说，只有该节点以及其祖先的桶中才一定会有这个答案的整体，也只会对该节点及以下非同祖子树答案产生干扰。也就是说，搜索一棵树时，其答案可以直接加到其祖先上，所以对于最后一颗子树，因为之后不会再干扰其他子树所以其答案可以直接上传至父节点。那么这个最后搜索的节点的子树应该越大越好，那么就可以使用树链剖分解决了。答案更新时，最后搜最大的即可。

对于时间复杂度，每次搜索最坏为O(n)，最大儿子上传是O(1)，小儿子上传为O(n)，轻儿子log₂n个所以时间复杂度为O(logn)

上代码：

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 struct pnt{
     int hd;
     int dp;
     int wgt;
     int mxs;
     int ans;
 }p[];
 struct ent{
     int twd;
     int lst;
 }e[];
 struct pr{
     int x,y;
     bool friend operator == (pr a,pr b){return (a.x==b.x)&&(a.y==b.y);}
     bool friend operator > (pr a,pr b){if(a.y==b.y)return a.x<b.x;return a.y>b.y;}
     bool friend operator < (pr a,pr b){if(a.y==b.y)return a.x>b.x;return a.y<b.y;}
     bool friend operator <= (pr a,pr b){return ((a<b)||(a==b));}
     bool friend operator >= (pr a,pr b){return ((a>b)||(a==b));}
 };
 class Prq{
     public:
         bool bol(void)
         {
             return (bool)(siz==);
         }
         void maxs(int &b)
         {
             b=line[].x;
         }
         void del(void)
         {
             line[]=line[siz--];
             int nw,nx;
             nw=;
             while((nw<<)<=siz)
             {
                 nx=nw<<;
                 if(nx<siz&&line[nx]<line[nx+])
                     nx++;
                 if(line[nx]<=line[nw])
                     break;
                 std::swap(line[nw],line[nx]);
                 nw=nx;
             }
             return ;
         }
         void ins(int a,int b)
         {
             pr tmp=(pr){a,b};
             line[++siz]=tmp;
             int nx,nw;
             nw=siz;
             while(nw>)
             {
                 nx=nw>>;
                 if(line[nx]>=line[nw])
                     break;
                 std::swap(line[nx],line[nw]);
                 nw=nx;
             }
             return ;
         }
         void dst(void)
         {
             siz=;
             return ;
         }
     private:
         pr line[];
         int siz;
 }Q;
 int n;
 int cnt;
 int num[];
 void ade(int f,int t)
 {
     cnt++;
     e[cnt].twd=t;
     e[cnt].lst=p[f].hd;
     p[f].hd=cnt;
 }
 void Basic_dfs(int x,int f)
 {
     p[x].dp=p[f].dp+;
     p[x].wgt=;
     int maxs=-;
     for(int i=p[x].hd;i;i=e[i].lst)
     {
         int to=e[i].twd;
         if(to==f)
             continue;
         Basic_dfs(to,x);
         p[x].wgt+=p[to].wgt;
         if(maxs<p[to].wgt)
         {
             maxs=p[to].wgt;
             p[x].mxs=to;
         }
     }
 }
 void Build_dfs(int x,int f)
 {
     num[p[x].dp]++;
     Q.ins(p[x].dp,num[p[x].dp]);
     for(int i=p[x].hd;i;i=e[i].lst)
     {
         int to=e[i].twd;
         if(to==f)
             continue;
         Build_dfs(to,x);
     }
 }
 void Destory_dfs(int x,int f)
 {
     num[p[x].dp]--;
     for(int i=p[x].hd;i;i=e[i].lst)
     {
         int to=e[i].twd;
         if(to==f)
             continue;
         Destory_dfs(to,x);
     }
 }
 void DSU_dfs(int x,int f,bool hvs)
 {
     if(!x)
         return ;
     for(int i=p[x].hd;i;i=e[i].lst)
     {
         int to=e[i].twd;
         if(to==f||to==p[x].mxs)
             continue;
         DSU_dfs(to,x,false);
     }
     DSU_dfs(p[x].mxs,x,true);
     for(int i=p[x].hd;i;i=e[i].lst)
     {
         int to=e[i].twd;
         if(to==f||to==p[x].mxs)
             continue;
         Build_dfs(to,x);
     }
     num[p[x].dp]++;
     Q.ins(p[x].dp,num[p[x].dp]);
     Q.maxs(p[x].ans);
     p[x].ans-=p[x].dp;
     if(hvs)
         return ;
     Destory_dfs(x,f);
     Q.dst();
     return ;
 }
 int main()
 {
     scanf("%d",&n);
     for(int i=;i<n;i++)
     {
         int x,y;
         scanf("%d%d",&x,&y);
         ade(x,y);
         ade(y,x);
     }
     Basic_dfs(,);
     DSU_dfs(,,true);
     for(int i=;i<=n;i++)
         printf("%d\n",p[i].ans);
     return ;
 }

2.树的长链剖分：

这个方法比上面的方法跑得快。

首先，观察那种最朴素的全搜一遍的O(n²)算法，它的瓶颈在于，统计答案时同一深度非同父的节点，其答案可能互相干扰，那么我们为何不合理安排内存使其答案不会互相被访问到而会同时被祖先访问到。类似于一个树链剖分序。类似长链先搜，短链后搜的剖分序。使用不同的下标索引使桶中的变量不会在深度环境下发生冲突，再logn统计答案就可以了，其实是O(nlogn)但重建部分比较简单常数较小且其最坏复杂度很难达到所以速度相当惊人。

上代码：

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 struct pnt{
     int hd;
     int dp;
     int mxs;
     bool vis;
     int ind;
     int ans;
     int wsa;
 }p[];
 struct ent{
     int twd;
     int lst;
 }e[];
 int n,m;
 int cnt;
 int wh;
 int tmp[];
 void ade(int f,int t)
 {
     cnt++;
     e[cnt].twd=t;
     e[cnt].lst=p[f].hd;
     p[f].hd=cnt;
 }
 void Basic_dfs(int x,int f)
 {
     p[x].dp=p[f].dp+;
     p[x].wsa=p[x].dp;
     for(int i=p[x].hd;i;i=e[i].lst)
     {
         int to=e[i].twd;
         if(to==f)
             continue;
         Basic_dfs(to,x);
         p[x].wsa=std::max(p[x].wsa,p[to].wsa);
         if(p[to].wsa>p[p[x].mxs].wsa)
         {
             p[x].mxs=to;
         }
     }
 }
 void Gund_dfs(int x,int f)
 {
     tmp[p[x].ind]=;
     if(p[x].mxs)
     {
         p[p[x].mxs].ind=p[x].ind+;
         Gund_dfs(p[x].mxs,x);
         p[x].ans=p[p[x].mxs].ans+;
     }
     for(int i=p[x].hd;i;i=e[i].lst)
     {
         int to=e[i].twd;
         if(to==f||to==p[x].mxs)
             continue;
         p[to].ind=wh;
         wh+=p[to].wsa-p[to].dp+;
         Gund_dfs(to,x);
         for(int j=;j<=p[to].wsa-p[to].dp;j++)
         {
             tmp[p[x].ind+j+]+=tmp[p[to].ind+j];
             if(tmp[p[x].ind+j+]>tmp[p[x].ind+p[x].ans]||(tmp[p[x].ind+j+]==tmp[p[x].ind+p[x].ans]&&p[x].ans>j+))
                 p[x].ans=j+;
         }
     }
     if(tmp[p[x].ind+p[x].ans]==)
         p[x].ans=;
 }
 int main()
 {
     scanf("%d",&n);
     for(int i=;i<n;i++)
     {
         int x,y;
         scanf("%d%d",&x,&y);
         ade(x,y);
         ade(y,x);
     }
     Basic_dfs(,);
     wh=p[].wsa;
     Gund_dfs(,);
     for(int i=;i<=n;i++)
         printf("%d\n",p[i].ans);
     return ;
 }