LCA(最近公共祖先)

定义
对于有根树T的两个结点u、v，最近公共祖先LCA(T,u,v)表示一个结点x，满足x是u、v的祖先且x的深度尽可能大。另一种理解方式是把T理解为一个无向无环图，而LCA(T,u,v)即u到v的最短路上深度最小的点。现在给定一个根为1的树，求某两个点的最近公共祖先。
思路：

预处理出每个点的深度再一层一层返回一直到找到相同点

deep[1]=1;void dfs(int nw,int d){    deep[nw]=d;    for(int i=0;i<G[nw].size();i++){        int to=G[nw][i];        if(!deep[to]){            par[to]=nw;            dfs(to,d+1);        }    }}

再返回

int LCA(int a,int b){    if(deep[a]>deep[b])swap(a,b);    while(deep[a]<deep[b])b=par[b];    while(a!=b){        a=par[a];        b=par[b];    }return a;}

复杂度约为O（n）
但是可以使用倍增优化
以par[i][j] 记录第i个点向上返回2^j的节点
因为2^j==2*2^（j-1）
即得到par[i][j]=ar[par[i][j-1]][j-1];
于是每次dfs出每个点的par[i][0]

void dfs(int c){    for(int i=0;i<G[c].size();i++){        int t=G[c][i];        if(!d[t]){            d[t]=d[c]+1;            par[t][0]=c;            dfs(t);        }       }   }

再利用动态规划计算出par[i][j]

for(int j=1;j<S;j++)    for(int i=1;i<=n;i++)    par[i][j]=par[par[i][j-1]][j-1];

于是我们可以利用类似快速幂的思想

int up(int a,int s){    for(int i=0;i<S;i++)        if(s&(1<<i))a=par[a][i];    return a;}

于是我们就得到了o（log2n）的算法

int LCA(int a,int b){    if(d[a]>d[b])swap(a,b);    b=up(b,d[b]-d[a]);    if(a!=b){    for(int i=S-1;i>=0;i--)        if(par[a][i]!=par[b][i])        a=par[a][i],b=par[b][i];        //找到最近的不同点     a=par[a][0];    //再上一层即为LCA     }return a;}