算法笔记：树上问题——LCA（最近公共祖先问题）

一.树上倍增解法

算法过程：

1.让两个点到达同一深度

2.让两个点一同往上走，保证不会到达相同的点

3.最后往上走最后一层

时间复杂度（mlogn）

const int N = le5+10;
vector<int>tree;
int deep[N];
int st[N][30];
 
//建立ST表
void dfs(int cur,int fa){
    deep[cur] = deep[fa]+1;
    st[cur][0] = fa;
    for(int i = 1;(1<<i)<=deep[cur];i++){
        st[cur][i] = st[st[cur][i-1]][i-1];
    }
    for(int i = 0;i<tree[cur].size();i++){
        if(tree[cur][i]!=fa){
            dfs(tree[cur][i],cur);
        }
    }
}

//求a，b的最近公共祖先
int lca(int a,int b){
    if(deep[a]<deep[b]){
        int t = a;
        a = b;
        b = t;
    }
    for(int i = 30;i>=0;i--){
        if(deep[st[a][i]]>=deep[b]){
            a = st[a][i];
        }
    }
    if(a==b){
        return a;
    }
    for(int i = 30;i>=0;i--){
        if(st[a][i]!=st[b][i]){
            a = st[a][i];
            b = st[b][i];
        }
    }
    return st[a][0];
}

二.tarjan算法

算法思想：

1.使用并查集来确定当前正在遍历子树的根，vis数组确定哪些节点访问过。

2.将每个问题记录两次（两个节点各记录一次），保证每个问题第一次没有处理掉，一定会在第二次处理。

时间复杂度（n+m）

const int N = len5+10;
int fa[N];//并查集
bool vis[N];//判断每个节点是否访问过
vector<int>tree;
vector<int>query;//每个节点的LCA问题
unordered_set<int>queryIndex;//每个LCA问题的索引，key是问题的两个节点
int ans[N];

//并查集查找祖先
int find(int i){
    if(i==fa[i]){
        return i;
    }else{
        fa[i] = find(fa[i]);
        return fa[i];
    }
}


void tarjan(int cur,int fa){
    vis[cur] = true;
    for(int i = 0;i<tree[cur].size();i++){
        int t = tree[cur][i];
        if(t!=fa){
            tarjan(t,cur);
            fa[t] = cur;
        }
    }
    for(int i = 0;i<query[cur].size();i++){
        int t = query[cur][i];
        if(vis[t]){
            ans[queryIndex[t]] = find(v);
        }
    }
}