LCA模板题https://www.luogu.com.cn/problem/P3379
题意理解
对于有根树T的两个结点u、v，最近公共祖先LCA(u,v)表示一个结点x，满足x是u、v的祖先且x的深度尽可能小。另一种理解方式是把T理解为一个无向无环图，而LCA(u,v)即u到v的最短路上深度最小的点。
例如，对于下面的树，结点4和结点6的最近公共祖先LCA(T,4,6)为结点2。 
那么这里提供四种思路。
1.暴力至上主义
首先计算出结点u和v的深度d1和d2。如果d1>d2，将u结点向上移动d1-d2步，如果d1<d2，将v结点向上移动d2-d1步，现在u结点和v结点在同一个深度了。下面只需要同时将u，v结点向上移动，直到它们相遇（到达同一个结点）为止，相遇的结点即为u，v结点的最小公共祖先。
但这个算法对于多次询问的题目不能解决。
2.倍增法
思路：倍增法其实是在上一种方法的基础上进行了优化，我们希望向上查找更快，可以事先预处理出p[i,j]，表示i往上移动2^j步到达的结点，这样在查找时将大大节约时间。利用P数组可以快速的将结点i向上移动n步，方法是将n表示为2进制数。比如n=6，二进制为110，那么利用P数组先向上移动4步(2^2)， 然后再继续移动2步(2^1)，即P[ P[i][2] ][1]。
那么首先深搜预处理出所有的p[i][j],并计算每个点的深度d[i]:
void dfs(int u,int fa)//从根结点u开始dfs，u的父亲是fa{ d[u]=d[fa]+1; //u的深度为它父亲的深度+1 p[u][0]=fa; //u向上走2^0步到达的结点是其父亲 for(int i=1;(1<<i)<=d[u];i++) p[u][i]=p[p[u][i-1]][i-1]; //预处理p时，保证能从u走到p[u][i] for(int i=head[u];i!=-1;i=e[i].next)//对于u的每个儿子{ int v=e[i].v; if(v!=fa)dfs(v,u); //递归处理以v为根结点的子树} }
然后在主函数中调用dfs(1,0)即可。接下来是查询结点a,b的LCA：
int lca(int a,int b) { if(d[a]>d[b]) swap(a,b) ; //保证a点在b点上面 for(int j=20;j>=0;j--) //将b点向上移动到和a的同一深度 if(d[a]<=d[b]-(1<<j)) b=p[b][j] ; if(a==b) return a ;//如果a和b相遇 for(int j=20;j>=0;j--)//a,b同时向上移动 { if(p[a][j]==p[b][j]) continue ;//如果a,b的2^j祖先相同，则不移动 a=p[a][j],b=p[b][j];//否则同时移动到2^j处 } return p[a][0] ;//返回最后a的父亲结点 }
时间复杂度分析
预处理：对每一个结点找到它向上走2^logN步到达的点，所以时间是NlogN
一组询问复杂度：O(logn)。
所以总复杂度为NlogN+QlogN
空间复杂度：O(nlogn)。
完整代码：
#include<stdio.h> #include<iostream> #define maxn 500000 using namespace std; int n,m,s,k=0; int dep[maxn+5],f[maxn+5][21]; int head[maxn+5]; struct edge{int u,v,next;}e[maxn*2+5]; inline int read() { int s=0,w=1; char ch=getchar(); while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();} while(ch>='0'&&ch<='9') s=s*10+ch-'0',ch=getchar(); return s*w; } void addedge(int u,int v) { e[++k].u=u; e[k].v=v; e[k].next=head[u]; head[u]=k; } void deal_first(int u,int father)//递归预处理 { dep[u]=dep[father]+1; for(int i=0;i<=19;i++) f[u][i+1]=f[f[u][i]][i]; for(int i=head[u];i;i=e[i].next) { int v=e[i].v; if(v==father) continue; f[v][0]=u; deal_first(v,u); } } int LCA(int x,int y)//查询x，y的LCA { if(dep[x]<dep[y]) swap(x,y);//保证x的深度更大 //先暴力，将x和y的深度调至一样 for(int i=20;i>=0;i--)//x先跳的幅度大一点 { if(dep[f[x][i]]>=dep[y]) x=f[x][i]; //x向上移动，使得x，y在同一深度 if(x==y) return x; //如果恰好x的祖先就是y，直接返回x，不过一般不可能 } for(int i=20;i>=0;i--)//x，y同时向上移动，找公共祖先 if(f[x][i]!=f[y][i])//x，y的父亲不同才往上跳 x=f[x][i],y=f[y][i]; return f[x][0];//最后x和y的父亲一样，返回x的父亲 } int main() { // ios::sync_with_stdio(false); n=read(),m=read(),s=read(); int x,y; for(int i=1;i<=n-1;i++) { x=read(),y=read(); addedge(x,y); addedge(y,x); } deal_first(s,0);//从根节点开始预处理 for(int i=1;i<=m;i++) { x=read(),y=read(); printf("%d\n",LCA(x,y)); } return 0; }
3.转为RMQ问题
思路：DFS遍历树T，将遍历到的结点按照顺序记下，得到一个长度为2N – 1的序列，称之为T的欧拉序列F。每个结点都在欧拉序列中出现，我们记录结点u在欧拉序列中第一次出现的位置为pos(u)。如下图：
根据DFS的性质，对于结点u、v，从pos(u)遍历到pos(v)的过程中经过LCA(u, v)至少一次，且是深度序列B[pos(u)…pos(v)]中值最小的元素在F中对应的节点。那么我们只需要去找在深度序列B中，pos（u）到pos（v）中最小的位置的欧拉序列值。
即LCA( u, v) = RMQ( pos(u), pos(v))。
用occur[]记录T的欧拉序列，depth[]记录深度，first[]记录各结点第一次出现在欧拉序列中的位置，深搜时：
void dfs(int u,int deep) { occur[++cnt]=u;//进入该点时进行记录 depth[cnt]=deep; if(!first[u]) first[u]=cnt; for(int i=head[u];i!=-1;i=e[i].next) { dfs(e[i].v,deep+1); occur[++cnt]=u;//访问子树也要标记 depth[cnt]=deep; } }
在这之后还需要进行一次预处理，打一次ST表。
时间复杂度分析：dfs时间为2N，RMQ预处理时间为NlogN，询问Q次，所以总时间复杂度为NlogN+Q
完整代码：
#include<iostream> #include<cstdio> #include<cstdlib> #include<cmath> #include<algorithm> #include<cstring> #define maxn 500000 using namespace std; int n,m,s,cnt=0,k=0,head[maxn+10]; struct edge{int u,v,next;}e[maxn*2+10]; int occur[maxn*2+10],depth[maxn*2+10],first[maxn+10]; int minnum[maxn*2+10][20],mindep[maxn*2+10][20]; //mindep记录的是区间内深度最小值 //minnum记录的是区间内深度最小值的编号 inline int read()//快读 { int s=0,w=1; char ch=getchar(); while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();} while(ch>='0'&&ch<='9') s=s*10+ch-'0',ch=getchar(); return s*w; } void addedge(int x,int y)//建边 { e[++k].u=x; e[k].v=y; e[k].next=head[x]; head[x]=k; } void dfs(int u,int deep)//深搜预处理 { cnt++; occur[cnt]=u; depth[cnt]=deep; first[u]=cnt;//记录首次出现的位置 for(int i=head[u];i!=-1;i=e[i].next) if(!first[e[i].v]) { dfs(e[i].v,deep+1);//深搜该节点的枝 occur[++cnt]=u;//回溯后，仍要将该节点放入欧拉数列 depth[cnt]=deep;//记录深度 } } void st()//st表求RMQ { for(int i=1;i<=cnt;i++) minnum[i][0]=occur[i],mindep[i][0]=depth[i]; for(int j=1;j<=log(cnt)/log(2);j++){ for(int i=1;i<=cnt-(1<<j)+1;i++) { if(mindep[i][j-1]<mindep[i+(1<<(j-1))][j-1]) mindep[i][j]=mindep[i][j-1],minnum[i][j]=minnum[i][j-1]; else mindep[i][j]=mindep[i+(1<<(j-1))][j-1],minnum[i][j]=minnum[i+(1<<(j-1))][j-1]; } } } int main() { memset(head,-1,sizeof(head)); n=read(),m=read(),s=read(); int x,y; for(int i=1;i<=n-1;i++) { x=read(),y=read(); addedge(y,x); addedge(x,y); } dfs(s,1); st(); for(int i=1;i<=m;i++) { x=read(),y=read(); int op=min(first[x],first[y]),ed=max(first[x],first[y]); int k=0; k=log(ed-op+1)/log(2); if(mindep[op][k]<mindep[ed-(1<<k)+1][k]) printf("%d\n",minnum[op][k]); else printf("%d\n",minnum[ed-(1<<k)+1][k]); } return 0; }
4.Tarjan
别说了，说多了都是泪。思路：先把所有的询问存下来，然后在DFS的过程中根据点被访问的状态求出每个询问的答案，DFS完后按询问顺序输出。需要用到并查集。
相比前两个算法，这是离线算法。优势在于稳定，且时间复杂度适中。
实现过程
DFS遍历树，利用并查集，当某个节点u及其子树遍历完成后,处理所有与u相关的查询。
1)当遍历到u时，创建u的并查集U={u},集合U的代表为u
2)对u的每一个子树进行DFS遍历,每搜索完一棵子树,将子树标记为checked,把子树所形成的集合与集合U合并，且集合U的代表仍为u
3)按步骤2)继续遍历u的下一棵子树，直到u的所有子树都遍历完,此时将u设为checked
4)处理所有与u相关的查询(u,v)
若v的状态为checked,则LCA(u,v)=present(v)
若v的状态不是checked，跳过这个查询(u,v)，当遍历到节点v时，u必然为checked，同样可以求得lca(u,v)
void tarjan(int u) { father[u]=u;//以u作为父亲建立一个独立并查集 vis[u]=true; for(int i=head[u];i!=-1;i=e[i].next) { int v=e[i].v; if(!vis[v]) { tarjan(v); father[v]=u; } } //深搜寻找叶子节点，再向上回溯 for(int i=0;i<q[u].size();i++) if(vis[q[u][i].first]&&!ans[q[u][i].second]) //如果这个点的并查集已被查询完，并且还没有得出答案 ans[q[u][i].second]=find(q[u][i].first); //第i号询问就是q[u][i].first的父亲 //同时对并查集的祖先进行刷新 }
时间复杂度分析：Tarjan的时间为N，每个询问O(1),所以总时间为N+Q
完整代码：
#include<iostream> #include<cstdio> #include<cstdlib> #include<algorithm> #include<cmath> #include<cstring> #include<vector> #define maxn 500000 using namespace std; int n,m,s,cnt=0,k=0,head[maxn+10]; struct edge{int u,v,next;}e[maxn*2+10]; int ans[maxn+10],father[maxn+10]; bool vis[maxn+10]; typedef pair<int,int> pii; vector<pii> q[maxn+10]; inline int read() { int ans=0,flag=1; char ch=getchar(); while(ch<'0'||ch>'9') { if(ch=='-') flag=-1; ch=getchar(); } while(ch>='0'&&ch<='9') ans=ans*10+ch-'0',ch=getchar(); return ans*flag; } void addedge(int u,int v) { e[++k].u=u; e[k].v=v; e[k].next=head[u]; head[u]=k; } int find(int x){return father[x]==x?x:father[x]=find(father[x]);} void tarjan(int u) { father[u]=u;//以u作为父亲建立一个独立并查集 vis[u]=true; for(int i=head[u];i!=-1;i=e[i].next) { int v=e[i].v; if(!vis[v]) { tarjan(v); father[v]=u; } } //深搜寻找叶子节点，再向上回溯 for(int i=0;i<q[u].size();i++) if(vis[q[u][i].first]&&!ans[q[u][i].second]) //如果这个点的并查集已被查询完，并且还没有得出答案 ans[q[u][i].second]=find(q[u][i].first); //第i号询问就是q[u][i].first的父亲 //同时对并查集的祖先进行刷新 } int main() { memset(head,-1,sizeof(head)); n=read(),m=read(),s=read(); int u,v; for(int i=1;i<=n-1;i++) { u=read(),v=read(); addedge(u,v); addedge(v,u); } for(int i=1;i<=m;i++) { u=read(),v=read(); q[u].push_back(make_pair(v,i)); q[v].push_back(make_pair(u,i)); }//不定长数组存储询问 tarjan(s); for(int i=1;i<=m;i++) printf("%d\n",ans[i]); return 0; }