LCA 离线算法 tarjan 总结 与模板题

LCA问题为最近公共祖先问题，常见的有一种在线的算法和一种离线的算法。这里介绍一下离线的tarjan算法。

离线算法需要首先读入所有的查询，然后重新组织对查询处理的顺序来达到更高效的处理。

tarjan算法使用的是dfs + 并查集的思想。

算法描述：

对于每一个dfs到的节点，就需要在并查集中创建一个以这个节点为独立的集合，然后继续dfs子树，当搜索完子树的时候，也就将与这个子树内的LCA询问处理完了，其他询问的结果就会在这个子树之外，那么将这个子树的根节点的集合和当前节点的集合合并，并将这个集合的祖先设置为当前的节点。继续搜索其他子树，直到将所有的子树搜索完成，那么就将当前这个节点设置为已经访问过，并且开始处理与当前节点有关的LCA询问，如果询问为当前点与点v之间的LCA，那么判断是否已经访问过v，如果已经访问过v，我们进行的是dfs，所以v与当前节点的最近公共祖先一定还没有被访问过，而v的子树已经全部搜索过了，那么最近公共祖先一定是v所在集合的祖先。

算法步骤：

从根节点开始dfs。

dfs 到u时:

1.遍历子节点 v:

tarjan(v)

合并v所在的集合和u所在的集合

设置u所在的集合的祖先为u

2.设置u已经访问过

3.处理与u有关的询问。如果询问(u,v)中的v已经访问过，那么LCA(u,v) = v所在集合的祖先

例题poj 1330

代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;
#define M 100009
int f[M];
int ancestor[M];
vector<int> tree[M];
vector<int> query[M];
int t,n;
int root;
int in[M];
bool vis[M];
int find(int x)
{
return x == f[x] ? f[x] : f[x] = find(f[x]);
}
int uni(int x,int y)
{
x = find(x);
y = find(y);
if(x != y) f[x] = y;
}
void init()
{
for(int i = 0;i <= n;i++)
{
vis[i] = false;
tree[i].clear();
query[i].clear();
in[i] = 0;
f[i] = i;
}
}
void input_tree()
{
for(int i = 0;i < n - 1;i++)
{
int a,b;
scanf("%d %d",&a,&b);
tree[a].push_back(b);
in[b]++;
}
for(int i = 1;i <= n;i++) if(in[i] == 0) root = i;
}
void input_query()
{
for(int i = 0;i < 1;i++)
{
int a,b;
scanf("%d %d",&a,&b);
query[a].push_back(b);
query[b].push_back(a);
}
}
void tarjan(int x)
{
for(int i = 0;i < tree[x].size();i++)
{
int v = tree[x][i];
tarjan(v);  //先处理子树
uni(x,v); //将儿子节点的集合和父亲节点的集合合并
ancestor[find(x)] = x; //将该节点所在集合的代表的祖先设置为x
}
vis[x] = true;
for(int i = 0;i < query[x].size();i++)
{
int v = query[x][i];
if(vis[v])
{
printf("%d\n",ancestor[find(v)]);
}
}
}
int main()
{
while(scanf("%d",&t) == 1)
{
while(t--)
{
scanf("%d",&n);
init();
input_tree();
input_query();
tarjan(root);//从根节点开始tarjan
}
}
return 0;
}