poj-2186 受欢迎的奶牛（tarjan算法应用）

题意：有n只奶牛，奶牛之间有倾慕的关系，并且倾慕关系是可以传递的。要求找出某几个奶牛，这几个奶牛被所有的奶牛喜欢。

奶牛的关系抽象成为有向图，a喜欢b表示为a点到b点有一条有向边。

思路：

1 通过tarjan算法，求出强连通分量，并且把这些强连通分量缩成缩点。通过这种方法把图转化为有向无环图。

2 在这个有向无环图中，如果存在唯一一个点A，这个点的出度为0，有向无环图中所有的点都有路径到达A。A点所代表的强连通分量中的点就是被所有奶牛喜欢的受欢迎奶牛。

思路详解：tarjan算法的详解以及原理在博客  tarjan算法原理介绍中，点击打开链接，计算缩点是先在tarjan算法出栈scc（强连通分量）的时候记录下每个点的scc编号，然后重新生成一张图。

思路中的步骤2证明如下：

一个有向图，不包含环路。如果有且只有一个点A的出度为0，则任意一个点都有一条路径到A。

运用数学归纳法证明：

1 当只有点A，B，且有B->A这一条路径，结论成立。

2 假设有n个节点和m条有向边，保证没有环路且只有A出度为零，任意一个点都有一条路径到A。

3 加入一个节点Z和任意几条有向边，保证没有环路且只有A出度为零（Z必然有一个出度连向2中的某个节点）。那么在2的基础上，Z可以到达2中的某个节点，而2中每个节点都有一条路径到A，所以Z也有一条路径到A。

 

综上所述，结论成立。

#include<iostream> 
#include<string>
#include<iomanip>
#include<vector>
using namespace std;

typedef struct node_arr_elem{
	int ID;
	vector<int> out_adj_node;
} node_arr_elem;
vector<node_arr_elem> adj_list, scc_adj; 

int pairs[100][2];
int scc_belonging[10000];//记录每个点属于的强连通分量 

int cmp(int index_1, int index_2){
	if(pairs[index_1][0]>pairs[index_2][0]){
		return 1;//>
	} else if(pairs[index_1][0]<pairs[index_2][0]){
		return -1;//<
	} else{
		if(pairs[index_1][1]>pairs[index_2][1]){
			return 1;//>
		} else if(pairs[index_1][1]<pairs[index_2][1]){
			return -1;//<
		} else{
			return 0;//=
		}
	}
}

void sort(int h, int l){
	int i,j,temp[2];
	if(h>l){
		temp[0] = pairs[l][0]; temp[1] = pairs[l][1];
		int state = 0;
		for(i=l,j=h;i<j;){
			if(state == 0){
				if(cmp(j,l)==-1){
					state = 1;
					pairs[i][0]=pairs[j][0];
					pairs[i][1]=pairs[j][1];
				} else{
					--j;
				}	
			}
			if(state == 1){
				if(cmp(i,l)==1){
					state = 0;
					pairs[j][0]=pairs[i][0];
					pairs[j][1]=pairs[i][1];
				} else{
					++i;
				}
			}
		}
		pairs[i][0] = temp[0];
		pairs[i][1] = temp[1];
		sort(l,i-1);
		sort(i+1,h);
	}
}
int delete_repeat(int num){
	sort(0,num-1);
	/*
	for(int i=0; i<num; ++i){
		cout<<pairs[i][0]<<"-"<<pairs[i][1]<<endl;
	}
	cout<<endl;*/
	
	int j=1,states = 0;
	for(int i=1;i<num;){
		if(pairs[i][0]==pairs[i-1][0]&&pairs[i][1]==pairs[i-1][1]){
			++i;
		}
		if(pairs[i][0]!=pairs[i-1][0]||pairs[i][1]!=pairs[i-1][1]){
			pairs[j][0] = pairs[i][0];
			pairs[j][1] = pairs[i][1];
			++j;++i;

		}
	}
	int new_length = j-1;
	return new_length; 
}

void create_graph(int n,int m,int choice){//生成图 
	
	for(int i=0; i<n; ++i){
		node_arr_elem new_n;
		new_n.ID = i+1;
		if(choice == 0)
			adj_list.push_back(new_n);
		else
			scc_adj.push_back(new_n);
	}
	for(int i=0; i<m; ++i){
		if(pairs[i][0]!=pairs[i][1]){
			if(choice == 0)
				adj_list[pairs[i][0]].out_adj_node.push_back(pairs[i][1]);
			else
				scc_adj[pairs[i][0]].out_adj_node.push_back(pairs[i][1]);
		}
	}
}

/*tarjan算法*/
vector<int> stack;
int low[10000] = {0};
int dfn[10000] = {0}; 
int time_stamp = 1;
int scc_count = 0;
int tarjan(int index){
	dfn[index] = low[index] = time_stamp++;
	stack.push_back(index);
	for(int i=0; i<adj_list[index].out_adj_node.size(); ++i){
		int v = adj_list[index].out_adj_node[i];
		if(find(stack.begin(),stack.end(),v) != stack.end()){
			low[index] = dfn[v]>low[index] ? low[index] : dfn[v];
		} else if(dfn[v] == 0){
			low[v] = tarjan(v);
			low[index] = low[v]>low[index] ? low[index] : low[v];
		}
	}
	if( dfn[index] == low[index] ){//发现强连通分量 
		//strong_connection s_c;
		int node;
		//connection_parts.push_back(s_c); 
		while( stack[stack.size()-1] != index ){
			node = stack[stack.size()-1]; 
			//connection_parts[connection_parts.size()-1].nodes.push_back(node);
			scc_belonging[node] = scc_count;//缩点，记录下这个点所属于的强连通分量 
			stack.pop_back();
		}
		node = stack[stack.size()-1]; 
		//connection_parts[connection_parts.size()-1].nodes.push_back(node);
		scc_belonging[node] = scc_count;
		stack.pop_back();
		
		++scc_count;
	}
	return low[index];
}
/*tarjan算法完*/

int main(){
	int n, m;
	cin>>n>>m;
	for(int i=0; i<m; ++i){
		cin>>pairs[i][0]>>pairs[i][1];
		--pairs[i][0];
		--pairs[i][1];
	}
	
	create_graph(n,m,0);//生成图 
	
	//求强连通分量 并 缩点 
	for(int finish=0; finish==0;){
		int j=-1;
		for(int i=0; i<n; ++i){
			if(dfn[i]==0){
				j=i;
			}
		}
		if(j!=-1){
			tarjan(j);//求强连通分量 
		} else{
			finish = 1;
		}
	}
	
	for(int i=0; i<m; ++i){
		pairs[i][0] = scc_belonging[pairs[i][0]];
		pairs[i][1] = scc_belonging[pairs[i][1]];
	}
	
	int new_m = delete_repeat(m);
	create_graph(scc_count,new_m,1);

	int num=0,scc_no;
	for(int i=0; i<scc_count; ++i){
		if(scc_adj[i].out_adj_node.size()==0){
			scc_no = i;
			++num;
		}
	}

	if(num==1){
		for(int i=0; i<n; ++i){
			if(scc_belonging[i] == scc_no){
				cout<<i+1<<" ";
			}
		}
	} else{
		cout<<"no";
	}
	
}