dsu on tree

好文推荐

思想

1. 先求当前树的轻子树上的问题，并且求完每个轻子树求完后清除信息
2. 再求当前树重子树信息，求完后不清除信息
3. 暴力求当前整棵树的信息o(n) n为当前树的结点个数，也就是合并整棵树上的信息，因为重子树信息已经保留，所以不用合并重子树的
4. 暴力合并时相当于将多个小的集合到那个最大的集合上，每个结点所在集合每合并一次集合体积增加2倍，最终变成一个大集合，所以每个集合最多被暴力合并logn次，每个集合一次暴力合并，时间复杂度是集合中点的个数，共n个点，时间复杂度 nlogn,话是这么说，可是我还是无法理解求每颗子树后时间复杂度还是是nlogn。

要点

1. 这个算法之所以可以到达nlogn的时间复杂度，很重要的一点是，它求解当前树的答案时，直接使用了当前树的重子树的答案，避免重复求解重子树信息，从而降低了时间复杂度，如果一个题没有用这个点，那么就做不到nlogn的时间复杂度。
2. 注意预处理要求的答案，或者优化求解答案的时间复杂度，dsu on tree 时间复杂是 n logn ，一定要防止求解答案过程中的复杂度退化
3. 注意数组越界，有时候要求的答案是不合法的，比如让你求一个在第5层的结点的它第3层儿子的数量，或者给你的层数大于树的有效层数
4. 当有多棵树时，因为要遍历多棵树，防止遍历上一颗树信息对下一棵树的影响，所以遍历每一棵树都要把根节点设置为轻链，遍历整棵树的最后要消除掉这棵树的信息。
5. 很多时候在cal的时候需要查找信息，要考虑是否可以不用map，虽然logn也很快，但是如果子树结点很多，logn对时间复杂度的影响就会很大。

难点

1. 脑袋里要有树的搜索的路径模型，知道它是怎么在树上走的
2. 思考如何高效的预处理，如何低复杂度的求得答案。

消除子树信息的方法，个人发现了2种，板子1是看别人的，板子2里的是自己想的，板子2消除子树信息更快点，当然不同情况适用不同方法。

板子1

对应题目 https://codeforces.com/problemset/problem/208/E
预处理 + dsu ， 用cal函数反标记消除信息，消除信息时间复杂度是 子树的结点个数

#include<bits/stdc++.h>
using namespace std;
#define IOS std::ios_base::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);// 快读

const int N = 100001;
int h[N],to[N],ne[N];
int son[N],high[N],sz[N];

//map<int,int> getfa[N];// 求父亲 存需要的父亲的位置
vector<pair<int,int> > ans;// 存子孙，与父亲差的层数     存父亲(个数，第几层（dp)   
map<int,int> qu[N];// 子孙，层数对应的父亲

map<int,int> need[N];// 记录结点，第几层的结点个数
vector<int> father; //记录祖先
vector<int> root; // 记录根节点
int tot[N];
int cnt = 0;
int nowson;//当前不需要统计的重树；
void add(int x,int y){
    to[++cnt] = y;
    ne[cnt] = h[x];
    h[x] = cnt;
}


void dfs(int u,int fa,int dp){//暴力求重子树
    
    high[u] = dp;
    for(auto &it : qu[u]){
        if(father.size() < it.first)    break;
        it.second = father[father.size() - it.first];
    }
    sz[u] = 1;
    father.push_back(u);
    for(int i = h[u]; ~i; i = ne[i]){
        int v = to[i];
        if(v == fa)    continue;
        dfs(v,u,dp + 1);
        sz[u] += sz[v];
        if(sz[v] > sz[son[u]]) son[u] = v;
    }
    father.pop_back();
    
}

void cal(int u,int fa,int val,int dp){// 合并子树，求树的价值，根据val值可以选择消除信息
    tot[dp] += val;
  
    
    for(int i = h[u]; ~i; i = ne[i]){
        int v = to[i];
        if(v == fa || v == nowson )    continue;//本意消除mason 的影响
        cal(v,u,val,dp + 1);
    }
}

void get_ans(int u,int fa,int op,int dp){ //op为1表示为重子树 0为轻子树
   
   
    for(int i = h[u];~i; i = ne[i]){
        int v = to[i];
        if(v == fa || v == son[u])    continue;
        get_ans(v,u,0,dp + 1);
    }
    

        nowson = 0;//清空标记，并且求重子树答案
        if(son[u]) get_ans(son[u],u,1,dp + 1);//-1 则无重子树
        
        nowson = son[u];//标记已经求得答案的重子树，这样就不用再求了
        cal(u,fa,1,dp),nowson = 0;//合并重子树和轻子树 nowson = 0这样就能抵消重子树的信息了
        for(auto &it : need[u]){
            
           it.second = tot[it.first];
//            if(u == 4)
//              cout << it.first << " " << it.first << " " << tot[it.first] << "\n";
        }
            
        
        if(!op) // val = 0 取消标记
        {
          //  cout << u << " " << deep[u] << endl;
            cal(u,fa,-1,dp);
//             for(int i = dp; i < deep[u] + dp;++i)
//                 tot[i] = 0;
        }
   
}

int main(){
    IOS
    memset(h,-1,sizeof h);
    int n,m;   cin >> n;
    for(int i = 1; i <= n; ++i){
        int x;  cin >> x;
        add(x,i); 
        if(!x)    root.push_back(i);
    }
    
   
//     for(auto it : ans[3]){
//         cout << it << endl;
//     }
    
    cin >> m;
    for(int i = 1 ; i <= m; ++i){
        int u,hi;    cin >> u >> hi;
        ans.push_back(pair<int,int>(u,hi));
        qu[u][hi] = -1;//如果为空父亲为 - 1
    }
    for(int i = 0; i < root.size(); ++i){
        dfs(root[i],-1,1);// 求每个结点的重子树
        //get_ans(root[i],-1,1,1);// 求每个结点的信息
    }
    
    for(int i = 0; i < m; ++i){
        int u = ans[i].first;
        ans[i].first = qu[ans[i].first][ans[i].second];// 父亲
        ans[i].second = high[u];// 第k层
        if(~ans[i].first)//如果有父亲
            need[ans[i].first][ans[i].second] = 1;
    }
    
    for(int i = 0; i < root.size(); ++i){
        //dfs(root[i],-1,1);// 求每个结点的重子树
        get_ans(root[i],-1,0,1);// 求每个结点的信息
    }
    
    for(int i = 0; i < m; ++i){
        //cout << i  + 1 << " " << ans[i].first << " " << ans[i].second << endl;
        if(~ans[i].first)
            cout << need[ans[i].first][ans[i].second] - 1 << " ";
        else cout << 0 << " ";
    }
    return 0;
    
}

板子2

对应题目 https://codeforces.com/problemset/problem/1009/F

利用子树所占用的对应树的高度，来消除信息，每次消除信息时间复杂度是这棵子树的高度，比上面消除信息的方法快点；

#include<bits/stdc++.h>
using namespace std;
#define IOS std::ios_base::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);// 快读

const int N = 1000010;
int h[N],to[N << 1],ne[N << 1];
int son[N],sz[N];

int ans[N],tot[N];//ans 保存答案，tot 记录遍历时的信息

int cnt = 0, res,layer, nowson;// res：所有层最大结点数，layer 第一个拥有最多结点数的层数编号，nowson当前不需要统计的重树；

void add(int x,int y){
    to[++cnt] = y;
    ne[cnt] = h[x];
    h[x] = cnt;
}

void dfs(int u,int fa,int dp){//暴力最深子树
    
    sz[u] = 1;
   
    for(int i = h[u]; ~i; i = ne[i]){
        int v = to[i];
        if(v == fa)    continue;
        dfs(v,u,dp + 1);
        sz[u] += sz[v];
        if(sz[v] > sz[son[u]]) son[u] = v;
    }
}

void cal(int u,int fa,int dp){// 合并子树，求树的价值，根据val值可以选择消除信息

    if(++tot[dp] > res || (tot[dp] == res && dp < layer))
        res = tot[dp], layer = dp;
    
  
    for(int i = h[u]; ~i; i = ne[i]){
        int v = to[i];
        if(v == fa || v == nowson )    continue;//本意消除mason 的影响
        cal(v,u,dp + 1);
    }
}

int get_ans(int u,int fa,int op,int dp){ //op为1表示为重链

    int madepth = dp;//最大深度
    for(int i = h[u];~i; i = ne[i]){
        int v = to[i];
        if(v == fa || v == son[u])    continue;
        madepth = max(madepth,get_ans(v,u,0,dp + 1));
    }

        nowson = 0;//清空标记，并且求重子树答案
        if(son[u]) madepth = max(madepth, get_ans(son[u],u,1,dp + 1));//-1 则无重子树
        
        nowson = son[u];//标记已经求得答案的重子树，这样就不用再求了
        cal(u,fa,dp),nowson = 0;//合并重子树和轻子树 nowson = 0这样就能抵消重子树的信息了
        //cout << u << " " << ma << " " << malayer << endl;
        ans[u] = layer - dp;
       
        if(!op) // val = 0 取消标记
        {
            res = layer = 0;
            for(int i = dp; i <= madepth; ++i)
                tot[i] = 0;
        }
        return madepth;
}

int main(){
    IOS
    memset(h,-1,sizeof h);
    int n;  cin >> n;
    for(int i = 1; i < n; ++i){
        int x,y; cin >> x >> y;
        add(x,y);add(y,x);
    }
    
    dfs(1,-1,1); get_ans(1,-1,0,1);
  
    for(int i = 1; i <= n; ++i){
      cout << ans[i] << '\n';
        
    }
    return 0;
}