(POJ1330)Tarjan算法模板

Nearest Common Ancestors
Time Limit: 1000MS Memory Limit: 10000K
Total Submissions: 39896 Accepted: 19766
Description
A rooted tree is a well-known data structure in computer science and engineering. An example is shown below:

In the figure, each node is labeled with an integer from {1, 2,…,16}. Node 8 is the root of the tree. Node x is an ancestor of node y if node x is in the path between the root and node y. For example, node 4 is an ancestor of node 16. Node 10 is also an ancestor of node 16. As a matter of fact, nodes 8, 4, 10, and 16 are the ancestors of node 16. Remember that a node is an ancestor of itself. Nodes 8, 4, 6, and 7 are the ancestors of node 7. A node x is called a common ancestor of two different nodes y and z if node x is an ancestor of node y and an ancestor of node z. Thus, nodes 8 and 4 are the common ancestors of nodes 16 and 7. A node x is called the nearest common ancestor of nodes y and z if x is a common ancestor of y and z and nearest to y and z among their common ancestors. Hence, the nearest common ancestor of nodes 16 and 7 is node 4. Node 4 is nearer to nodes 16 and 7 than node 8 is.

For other examples, the nearest common ancestor of nodes 2 and 3 is node 10, the nearest common ancestor of nodes 6 and 13 is node 8, and the nearest common ancestor of nodes 4 and 12 is node 4. In the last example, if y is an ancestor of z, then the nearest common ancestor of y and z is y.

Write a program that finds the nearest common ancestor of two distinct nodes in a tree.
Input
The input consists of T test cases. The number of test cases (T) is given in the first line of the input file. Each test case starts with a line containing an integer N , the number of nodes in a tree, 2<=N<=10,000. The nodes are labeled with integers 1, 2,…, N. Each of the next N -1 lines contains a pair of integers that represent an edge --the first integer is the parent node of the second integer. Note that a tree with N nodes has exactly N - 1 edges. The last line of each test case contains two distinct integers whose nearest common ancestor is to be computed.
Output
Print exactly one line for each test case. The line should contain the integer that is the nearest common ancestor.
Sample Input
2
16
1 14
8 5
10 16
5 9
4 6
8 4
4 10
1 13
6 15
10 11
6 7
10 2
16 3
8 1
16 12
16 7
5
2 3
3 4
3 1
1 5
3 5
Sample Output
4
3

题解：这是一道LCA的一道模板题，之前看了好久都不明白什么意思，在前面学了强连通的Tarjan算法之后发先这两个算法差不多，带着同样的是呀去学习这个算法有很大的帮助，下面介绍一个学习博客：https://blog.csdn.net/my_sunshine26/article/details/72717112

什么是Tarjan算法呢，个人理解是基于DFS改编的一个算法，利用的是DFS的递归回溯性质去实现一下其他算法没有的东西。

一.Tarjan算法大致实现过程
1.先选择一个节点尾根节点u，从根节点开始深度搜索。
2.遍历u的所有相邻节点v，并标记已经访问过。
3.若v还有相邻节点，对v进行2操作。
4.当没有相邻节点的时候，把v合并到u集合上，另u为v的父节点
5.把当前节点设为u，遍历u的所有询问关系的节点v
6.如果v在之前已经访问过，那么u和v的LCA是通过并查集合并后的父节点（find(v)）。

核心代码（Tarjan）：

void tarjan(int now){
	vis[now]=1;//标志访问过 
	for(int i=0;i<mp[now].size();i++){
		int t=mp[now][i];//获取相邻节点 
		if(vis[t]==0){//如果没有访问过，但是对树来说没必要 
			tarjan(t);//深搜 
			pre[t]=now;//深搜推出之后，置t的父节点now 
		}
	}//当now的所有相邻节点访问完毕 ，处理访问关系 
	for(int i=0;i<q[now].size();i++){
		int t=q[now][i];//读取访问关系 
		if(vis[t]==1){//如果访问过 
			ans=father(t);//输出t当前的祖先 
		}
	}
	return ;
}

在ans=father(t)这里，t可能会有很多个祖先节点，但是我们输出的是两个节点的LCA，那么t现在的祖先就是最近公共祖先了。

AC代码：

#include<iostream>
#include<string.h>
#include<vector>
#define maxn 10010
using namespace std;
vector<int> mp[maxn];
vector<int> q[maxn];
int vis[maxn];
int pre[maxn];
int degree[maxn];
int n,x,y,ans;
int father(int x){
	if(x==pre[x])
		return x;
	else
		return father(pre[x]);
}
void tarjan(int now){
	vis[now]=1;//标志访问过 
	for(int i=0;i<mp[now].size();i++){
		int t=mp[now][i];//获取相邻节点 
		if(vis[t]==0){//如果没有访问过，但是对树来说没必要 
			tarjan(t);//深搜 
			pre[t]=now;//深搜推出之后，置t的父节点now 
		}
	}//当now的所有相邻节点访问完毕 ，处理访问关系 
	for(int i=0;i<q[now].size();i++){
		int t=q[now][i];//读取访问关系 
		if(vis[t]==1){//如果访问过 
			ans=father(t);//输出t当前的祖先 
		}
	}
	return ;
}
void init(){
	memset(vis,0,sizeof(vis));
	memset(degree,0,sizeof(degree));
	for(int i=1;i<=n;i++){
		pre[i]=i;
		mp[i].clear();
		q[i].clear();
	}
}
int main(){
	int t;
	cin>>t;
	while(t--){
		cin>>n;
		init();
		for(int i=0;i<n-1;i++){
			cin>>x>>y;
			mp[x].push_back(y);
			degree[y]++;
		}
		cin>>x>>y;
		q[x].push_back(y);
		q[y].push_back(x);
		int root=0;
		for(int i=1;i<=n;i++){
			if(degree[i]==0){
				root=i;
				break;
			}
		}
		ans=-1;
		tarjan(root);
		cout<<ans<<endl;
	}
	return 0;
}

这篇博客还没完善，还回再修改-2019.11.29。