HDU 3639 Hawk-and-Chicken 支持传递

http://acm.hdu.edu.cn/showproblem.php?pid=3639

#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
using namespace std;
#define N 5005
#define M 30005
int top,bcnt;
int stack[N],index;
bool instack[N];
int belong[N];
int dfn[N],low[N];
vector<int> E[N]; // 存储原始的有向图 
vector<int> FE[N]; // 存储缩点后的逆图 
vector<int> SCC[N]; // 存储每个缩点 所包含的点

//-----------初始化------------// 
void init(int n){
	bcnt=top=index=0; 
	for(int i=0;i<=n;i++){
		E[i].clear();
		FE[i].clear();
		SCC[i].clear();
	}
	memset(instack,0,sizeof(instack));
	memset(dfn,0,sizeof(dfn));
	memset(low,0,sizeof(low));
}

//---------求强连通分量-------// 
void tarjan(int u){
	dfn[u]=low[u]=++index;
	instack[u]=true;
	stack[top++]=u;
	for(int i=0;i<E[u].size();i++){
		int v=E[u][i];
		if(!dfn[v]){
			tarjan(v);
			if(low[v]<low[u])
				low[u]=low[v];
		}
		else if(instack[v]&&dfn[v]<low[u])
			low[u]=dfn[v];
	}
	if(low[u]==dfn[u]){
		bcnt++;
		int v;
		do{
			v=stack[--top];
			instack[v]=false;
			belong[v]=bcnt;
		}while(u!=v);
	}
}

int in[N];//  存储每个缩点的入度 
bool h[N];//  标记缩点是否访问过 

//---------对逆图求和----------// 
void dfs(int u,int &sum){
	for(int i=0;i<FE[u].size();i++){
		int v=FE[u][i];
		if(!h[v]){
			h[v]=1;
			sum+=SCC[v].size(); 
			dfs(v,sum);
		}
	}
}

int main(void){
	int t,k=1;
	scanf("%d",&t);
	while(t--){
		int n,m;
		scanf("%d%d",&n,&m);
		init(n);
		for(int i=0;i<m;i++){
			int u,v;
			scanf("%d%d",&u,&v);
			u++;v++;
			E[u].push_back(v);
		}
		for(int i=1;i<=n;i++)
			if(!dfn[i])
				tarjan(i);
		for(int i=1;i<=n;i++)
			SCC[belong[i]].push_back(i); // 记录每个缩点所包含的点集 
		memset(in,0,sizeof(in));
		for(int i=1;i<=n;i++)
			for(int j=0;j<E[i].size();j++){
				int x=belong[i];
				int y=belong[E[i][j]];
				if(x!=y){
					FE[y].push_back(x); // 逆图！关键 
					in[x]++;            //入度++ 
				}
			}
		int Max=-1;
		vector<int> ret; // 存储哪些缩点支持数量是最大的 ，结果并不是只有一个 
		for(int i=1;i<=bcnt;i++)
			if(in[i]==0){
				memset(h,0,sizeof(h));
				int sum=0;
				h[i]=1;
				dfs(i,sum);
				sum+=SCC[i].size()-1; // 要加上自己本身所在的 集合数-1 
				if(sum>Max){          // 如果比最大值大，那么更新最大值，ret也要更新 
					Max=sum;
					ret.clear();
					ret.push_back(i);
				}
				else if(sum==Max)     // 如果相等，那么说明有新的缩点支持数是一样的 
					ret.push_back(i);
			}
		vector<int> ans;              //保存最后答案 ，遍历每个最大支持数的缩点 
		for(int i=0;i<ret.size();i++){
			int u=ret[i]; 
			for(int j=0;j<SCC[u].size();j++) //SCC[u]保存的就是u这个缩点里面的点集合 
				ans.push_back(SCC[u][j]-1);
		}
		sort(ans.begin(),ans.end()); //结果排序后输出 
		printf("Case %d: %d\n",k++,Max);
		printf("%d",ans[0]);
		for(int i=1;i<ans.size();i++)
			printf(" %d",ans[i]);
		printf("\n");
	}
}
			

1.支持票数是可以传递的，再加上有向图，想到强连通

2.每个强连通分量里面的点是可以互相传递的，那么票数首先就是该分量的 容量-1

3.再考虑各个分量之间的传递关系，对于一个分量，他有很多传递出去的票，如果遍历每个分量里面的点，再从这些点发散出去寻找的话很不方便，可以转换成逆图，那么对于一个分量来说，这个分量能获得的票数支持 就是这个分量 发散出去 能到达的 其他分量数，可以用递归解决

4.此外，最大值肯定是在那些入度为0的分量中的，如果假设最大值存在于一个入度不为0的分量中，那么连接这个分量的 那个分量票数支持肯定大于这个分量，假设不成立

5.最巧妙的就是把点转化为一个个强连通分量来看，把分量看成一个点，最后再看哪些分量是最大，转换回 原始点