HDU3639Hawk-and-Chicken （好题，强连通缩点，建图，DFS回溯）

题意：大家玩老鹰抓小鸡的游戏，但是大家都想做老鹰，所以老师安排一个投票，每个人不能投自己，但是可以投多个人，投票具有传递性，比如A–>B, B–>C,那么B获得A一票，C获得B一票，A一票，共计2票。现在问谁能胜出，并列的也算，输出胜出者的票数，以及升序输出，获胜的编号。

思路：由于大家投票，可能有环，所以需要Ｔａｒｊａｎ算法把图转换为ＤＡＧ，然后进行搜索，但是如果缩点后正向建图，搜索时会发现，如果一个点有多条路径到达，会出现重复计数，所以反向建图，因为，最终获胜的人，肯定是叶子结点，所以我们从叶子节点反向建图，用ＤＦＳ搜索，回溯的时候更新，就不会出现重复计数。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<set>
#include<map>
#include<string>
#include<cstring>
#include<stack>
#include<queue>
#include<vector>
#include<cstdlib>
#define lson (rt<<1),L,M
#define rson (rt<<1|1),M+1,R
#define M ((L+R)>>1)
#define cl(a,b) memset(a,b,sizeof(a));
#define LL long long
#define P pair<int,int>
#define X first
#define Y second
#define pb push_back
#define fread(zcc)  freopen(zcc,"r",stdin)
#define fwrite(zcc) freopen(zcc,"w",stdout)
using namespace std;
const int maxn=50005;
const int inf=999999;

vector<int> belong2[maxn];//属于某一块的连通图的所有节点集合
vector<int> ans;//答案
int dp[maxn];//保存缩点后每个“点”的权值

vector<int> G[maxn];
int low[maxn],dfn[maxn],s[maxn],belong[maxn];
bool ins[maxn];
int num,cnt,top;
void dfs(int u){
low[u]=dfn[u]=++num;
s[top++]=u;
ins[u]=true;
int N=G[u].size();
for(int i=0;i<N;i++){
int v=G[u][i];
if(!dfn[v]){
dfs(v);
low[u]=min(low[u],low[v]);
}
else if(ins[v]&&dfn[v]<low[u]){
low[u]=dfn[v];
}
}
if(low[u]==dfn[u]){
int v=-1;
cnt++;
while(u!=v){
v=s[--top];
ins[v]=false;
belong[v]=cnt;
belong2[cnt].pb(v);
}
}
}

void Tarjan(int n){
num=cnt=top=0;
cl(ins,false);
cl(belong,0);
cl(dfn,0);
for(int i=1;i<=n;i++)if(!dfn[i]){
dfs(i);
}
}
int out[maxn];//出度
vector<int> G2[maxn];//缩点，后的图
int en[maxn];//达到当前点，所能获得的最大票数
int myans;
bool vis[maxn];//标记
void dfs2(int u){

int N=G2[u].size();
for(int i=0;i<N;i++){
if(vis[G2[u][i]])continue;
vis[G2[u][i]]=true;
dfs2(G2[u][i]);
myans+=dp[G2[u][i]]+1;//回溯的时候更新，到这个点的最大值
}

}
int t[maxn];
int main(){
//fread("Text/in.txt");
int T;
scanf("%d",&T);
int cas=1;
while(T--){
int n,m;
scanf("%d%d",&n,&m);
for(int i=0;i<=n;i++){
G[i].clear();
belong2[i].clear();
G2[i].clear();
}
ans.clear();
for(int i=0;i<m;i++){
int x,y;
scanf("%d%d",&x,&y);
x++;y++;
G[x].pb(y);
}
Tarjan(n);

for(int i=1;i<=cnt;i++){
dp[i]=belong2[i].size()-1;
}

cl(out,0);
for(int u=1;u<=n;u++){
for(int j=0;j<G[u].size();j++){
int v=G[u][j];
if(belong[u]!=belong[v]){
out[belong[u]]++;
G2[belong[v]].pb(belong[u]);//缩点，建立反向图
// printf("belong[v]  =  %d ,belng[u] = %d\n",belong[v],belong[u]);
}
}
}

cl(en,0);
for(int i=1;i<=cnt;i++)if(out[i]==0){//从出度是0的点，也就是叶子节点，计算每个叶子节点的值
myans=0;
cl(vis,false);
dfs2(i);
en[i]=myans;
//printf("i = %d, myans = %d\n",i,myans);
}

int mx=0;
cl(t,0);
for(int i=1;i<=n;i++){
t[i]=en[belong[i]]+dp[belong[i]];//t[i]，是最终的叶子节点的值
mx=max(mx,t[i]);
}

for(int i=1;i<=n;i++)if(t[i]==mx){
ans.pb(i);
}

sort(ans.begin(),ans.end());
printf("Case %d: %d\n",cas++,mx);
printf("%d",ans[0]-1);
for(int i=1;i<ans.size();i++){
printf(" %d",ans[i]-1);
}
printf("\n");

}
return 0;
}