10.3 (2) 到不了

Description
wy  和  wjk  是好朋友。
今天他们在一起聊天，突然聊到了以前一起唱过的《到不了》。
“说到到不了，我给你讲一个故事吧。”
“嗯？”
“从前，神和凡人相爱了，愤怒的神王把他们关进了一个迷宫里，迷宫是由许多棵有根树组
成的。神王每次把两个人扔进其中的某一棵有根树里面，两个相邻节点的距离为  1，两人的
每一步都只能从儿子走到父亲，不能从父亲走到儿子，他们约定，走到同一个节点相见，由
于在迷宫里面行走十分消耗体力，他们决定找出那个使得他们走的总路程最少的节点，他们
当然会算出那个节点了，可是神王有时候会把两棵有根树合并为一棵，这下就麻烦了。。。”
“唔。。。”
[已经了解树，森林的相关概念的同学请跳过下面一段]
树：由  n  个点，n-1  条边组成的无向连通图。
父亲/儿子：把树的边距离定义为  1,root  是树的根，对于一棵树里面相邻的两个点  u,v，到
root 的距离近的那个点是父亲，到  root  距离远的那个点是儿子
森林：由若干棵树组成的图
[简化版题目描述]
维护一个森林，支持连边操作和查询两点  LCA  操作
Input
第一行一个整数  N，M，代表森林里的节点总数和有根树的数目。
第二行  M  个整数，第  i  个整数  ri  代表第  i  棵有根树的根是编号为  ri  的节点
接下来  N-M  行，每行两个整数  u，v  表示  u  和  v  相邻
接下来一行一个整数  Q，表示  Q  个事件发生了

接下来  Q  行，每行若干个整数，表示一个事件
如果第一个数  op=1，接下来两个整数  u,v,代表神王把  u  号节点所在的树和  v  号节点所在
的树合并到一起(即  u  到  v  连了一条边)，新的根为原来  u  号节点所在的树的根(如果  u,v 
已经联通，忽略这个事件)。
如果第一个数  op=2，接下来两个整数  u，v，代表一次询问，当一个人在  u  号节点，一个
人在  v  号节点，询问他们找到的那个节点的编号
Output 
对于每一个询问(op=2  的操作)，输出一行一个整数，代表节点编号，如果  u，v  不联通，
输  出  orzorz。 
Sample Input 
【样例  1】
2 2 
1 2 
2 
1 1 2
2 1 2 
【样例  2】 
2 2 
1 2 
2 
1 2 1 
2 1 2 
Sample Output 
【样例  1】 
1 
【样例  2】 
2
Hint 
【数据范围】 
对于  30%的数据  1 ≤ N ≤ 1000 1 ≤ Q ≤ 1000 
对于  100%的数据  1 ≤ N ≤ 100000 1 ≤ Q ≤ 100000

 

题解：启发式合并两棵树的  LCA  倍增数组，每次总是把节点数少的那棵树合并到节点多的那棵树上

重新建立连边的那一可树，找距离时即从深度比较深的lca入手

 

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define out(x) print(x)
const int MAXN = 1e5 + 5;
int f[MAXN][21];
int dep[MAXN],rt[MAXN],root[MAXN];
int size[MAXN];
int head[MAXN*2],cnt = 0;

struct node {
    int next,to;
    
} e[MAXN*2];

void add(int u,int v) {
    
    e[++cnt].next = head[u],e[cnt].to = v,head[u] = cnt;
    e[++cnt].next = head[v],e[cnt].to = u,head[v] = cnt;
    
}
int n,m,q,E;

void rebuild(int x,int fr) {
    
    for(int i = 1; i <= 20; i++) f[x][i] = f[f[x][i-1]][i-1];
    
    for(int i = head[x]; i; i = e[i].next) {
        int to = e[i].to;
        if(to == fr) continue;
        dep[to] = dep[x] + 1;
        f[to][0] = x;
        rebuild(to,x);
    }
}

void dfs(int x,int fr) {
    
    f[x][0] = fr;
    
    for(int i = head[x]; i; i = e[i].next) {
        
        int to = e[i].to;
        if(to == fr) continue;
        dep[to] = dep[x] + 1;
        dfs(to,x);
        size[x] += size[to];
    }
}

int get(int x) {
    
    for(int i = 20; i >= 0; i--) if(f[x][i]) x = f[x][i];
    return x;
    
}

int lca(int x,int y) {
    
    if(dep[x] < dep[y]) swap(x,y);
    
    for(int i = 20; i >= 0; i--)
        if(dep[x] - (1 << i) >= dep[y])
            x = f[x][i];
            
    if(x == y) return x;
    
    for(int i = 20; i >= 0; i--)
        if(f[x][i] != f[y][i])
            x = f[x][i],y = f[y][i];
            
    return f[x][0];
}

int main() {
    
    cin>>n>>m;
    for(int i = 1; i <= m; i++) cin>>rt[i];
    int e;
    cin>>e;
    
    for(int i = 1; i <= n-m; i++) {
        int x,y;
        cin>>x>>y;
        add(x,y);
    }
    
    for(int i = 1; i <= n; i++) size[i] = 1;
    
    for(int i = 1; i <= m; i++) {
        dep[rt[i]] = 1;
        dfs(rt[i],0);
    }
    
    for(int j = 1; j <= 20; j++)
        for(int i = 1; i <= n; i++)
            f[i][j] = f[f[i][j-1]][j-1];
            
    for(int i = 1; i <= n; i++) {
        int o = get(i);
        
        if(o) root[i] = o;
        else root[i] = i;
    }
    
    cin>>q;
    
    for(int i = 1; i <= q; i++) {
        int o,u,v;
        cin>>o>>u>>v;
        
        if(o == 1) {
            int x = get(u),y = get(v);
            if(x == y) continue;
            if(size[x] > size[y]) {
                f[v][0] = u;
                size[x] += size[y];
                dep[v] = dep[u] + 1;
                root[y] = root[x];
                add(u,v);
                rebuild(v,u);
            }
            else {
                f[u][0] = v;
                size[y] += size[x];
                dep[u] = dep[v] + 1;
                root[y] = root[x];
                add(u,v);
                rebuild(u,v);
            }
        } else {
            int a = u;
            int b = v;
            if(get(a) != get(b)) {
                cout << "orzorz" << endl;
                continue;
            } 
            else {
                int c = get(a);
                
                int a = lca(u,v);
                
                int b = lca(root[c],v);
                
                if(dep[a] < dep[b]) a = b;
                b = lca(root[c],u);
                
                if(dep[a] < dep[b]) a = b;
                cout<<a<<endl;
            }
        }
    }
    return 0;
}