最近公共祖先LCA：Tarjan算法

1,并查集+dfs
对整个树进行深度优先遍历，并在遍历的过程中不断地把一些目前可能查询到的并且结果相同的节点用并查集合并.

2,分类，使每个结点都落到某个类中，到时候只要执行集合查询，就可以知道结点的LCA了。
对于一个结点u.类别有:
以u为根的子树、除类一以外的以f(u)为根的子树、除前两类以外的以f(f(u))为根的子树、除前三类以外的以f(f(f(u)))为根的子树……

类一的LCA为u,类二为f(u),类三为f(f(u)),类四为f(f(f(u)))。这样的分类看起来好像并不困难。
但关键是查询是二维的，并没有一个确定的u。接下来就是这个算法的巧妙之处了。
利用递归的LCA过程。
当lca(u)执行完毕后，以u为根的子树已经全部并为了一个集合。而一个lca的内部实际上做了的事就是对其子结点，依此调用lca.
当v1(第一个子结点)被lca，正在处理v2的时候，以v1为根的子树＋u同在一个集合里，f(u)+编号比u小的u的兄弟的子树　同在一个集合里，f(f(u))　+　编号比f(u)小的　f(u)的兄弟　的子树　同在一个集合里……　
而这些集合，对于v2的LCA都是不同的。因此只要查询x在哪一个集合里，就能知道LCA(v2,x)

还有一种可能，x不在任何集合里。当他是v2的儿子，v3,v4等子树或编号比ｕ大的ｕ的兄弟的子树（等等）时，就会发生这种情况。即还没有被处理。还没有处理过的怎么办？把一个查询(x1,x2)往查询列表里添加两次，一次添加到x1的列表里，一次添加到x2的列表里，如果在做x1的时候发现 x2已经被处理了，那就接受这个询问。（两次中必定只有一次询问被接受）.

3,应用:http://acm.pku.edu.cn/JudgeOnline/problem?id=1330
实现代码:

Cpp代码  

1. #include<iostream>  
2. #include<vector>  
3. using namespace std;  
4.   
5. const int MAX=10001;  
6. int f[MAX];  
7. int r[MAX];  
8. int indegree[MAX];//保存每个节点的入度  
9. int visit[MAX];  
10. vector<int> tree[MAX],Qes[MAX];  
11. int ancestor[MAX];  
12.   
13.   
14. void init(int n)  
15. {  
16.     for(int i=1;i<=n;i++)  
17.     {  
18.   
19.         r[i]=1;  
20.         f[i]=i;  
21.         indegree[i]=0;  
22.         visit[i]=0;  
23.         ancestor[i]=0;  
24.         tree[i].clear();  
25.         Qes[i].clear();  
26.     }  
27.   
28. }  
29.   
30. int find(int n)  
31. {  
32.     if(f[n]==n)  
33.         return n;  
34.     else  
35.         f[n]=find(f[n]);  
36.     return f[n];  
37. }//查找函数，并压缩路径  
38.   
39. int Union(int x,int y)  
40. {  
41.     int a=find(x);  
42.     int b=find(y);  
43.     if(a==b)  
44.         return 0;  
45.     //相等的话,x向y合并  
46.     else if(r[a]<=r[b])  
47.     {  
48.         f[a]=b;  
49.         r[b]+=r[a];  
50.     }  
51.     else  
52.     {  
53.         f[b]=a;  
54.         r[a]+=r[b];  
55.     }  
56.     return 1;  
57.   
58. }//合并函数，如果属于同一分支则返回0，成功合并返回1  
59.   
60.   
61. void LCA(int u)  
62. {  
63.     ancestor[u]=u;  
64.     int size = tree[u].size();  
65.     for(int i=0;i<size;i++)  
66.     {  
67.         LCA(tree[u][i]);  
68.         Union(u,tree[u][i]);  
69.         ancestor[find(u)]=u;  
70.     }  
71.     visit[u]=1;  
72.     size = Qes[u].size();  
73.     for(int i=0;i<size;i++)  
74.     {  
75.         //如果已经访问了问题节点,就可以返回结果了.  
76.         if(visit[Qes[u][i]]==1)  
77.         {  
78.             cout<<ancestor[find(Qes[u][i])]<<endl;  
79.             return;  
80.         }  
81.     }  
82. }  
83.   
84.   
85. int main()  
86. {  
87.     int cnt;  
88.     int n;  
89.     cin>>cnt;  
90.     while(cnt--)  
91.     {  
92.         cin>>n;;  
93.         init(n);  
94.         int s,t;  
95.         for(int i=1;i<n;i++)  
96.         {  
97.             cin>>s>>t;  
98.             tree[s].push_back(t);  
99.             indegree[t]++;  
100.         }  
101.         //这里可以输入多组询问  
102.         cin>>s>>t;  
103.         //相当于询问两次  
104.         Qes[s].push_back(t);  
105.         Qes[t].push_back(s);  
106.         for(int i=1;i<=n;i++)  
107.         {  
108.             //寻找根节点  
109.             if(indegree[i]==0)  
110.             {  
111.                 LCA(i);  
112.                 break;  
113.             }  
114.         }  
115.     }  
116.     return 0;  
117. }