Hawk-and-Chicken

Time Limit: 6000/2000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)

Total Submission(s): 39 Accepted Submission(s): 25

Problem Description

Kids in kindergarten enjoy playing a game called Hawk-and-Chicken. But there always exists a big problem: every kid in this game want to play the role of Hawk.
So the teacher came up with an idea: Vote. Every child have some nice handkerchiefs, and if he/she think someone is suitable for the role of Hawk, he/she gives a handkerchief to this kid, which means this kid who is given the handkerchief win the support. Note the support can be transmitted. Kids who get the most supports win in the vote and able to play the role of Hawk.(A note:if A can win
support from B(A != B) A can win only one support from B in any case the number of the supports transmitted from B to A are many. And A can't win the support from himself in any case.
If two or more kids own the same number of support from others, we treat all of them as winner.
Here's a sample: 3 kids A, B and C, A gives a handkerchief to B, B gives a handkerchief to C, so C wins 2 supports and he is choosen to be the Hawk.

Input

There are several test cases. First is a integer T(T <= 50), means the number of test cases.
Each test case start with two integer n, m in a line (2 <= n <= 5000, 0 <m <= 30000). n means there are n children(numbered from 0 to n - 1). Each of the following m lines contains two integers A and B(A != B) denoting that the child numbered A give a handkerchief to B.

Output

For each test case, the output should first contain one line with "Case x:", here x means the case number start from 1. Followed by one number which is the total supports the winner(s) get.
Then follow a line contain all the Hawks' number. The numbers must be listed in increasing order and separated by single spaces.

Sample Input

Sample Output

Case 1: 2
0 1
Case 2: 2
0 1 2

Author

Dragon

Source

2010 ACM-ICPC Multi-University Training Contest（19）——Host by HDU

Recommend

lcy

/*
题意：投票，投票是可以传递的，比如A投给B，B投给C，C就会得到两票

初步思路：将投票的关系建成单向边的图，然后如果是在一个强连通子图中的肯定每人都能得到强连通顶点数-1的票数。
    然后，剩下不是强连通子图的，只要是连成一片了，每条路的末尾的那个定点肯定能得到这条路的长度-1的票数。
    
#错误：上面的思想有点错误，连成一片之后不需要考虑，是不是入度为零，但是去掉之后超时了.....

#补充：上面的想的有点问题，判断连成片的时候，不是判断点和点之间的片，而是连通块和连通块之间的片
*/
#include<bits/stdc++.h>
using namespace std;
/**************************强连通模板******************************/
const int maxn = 5000 + 7;
vector<int> G1[maxn];//正向  
vector<int> G2[maxn];//逆向
int vis[maxn];//记录每个点逆向的入度
int num[maxn];//用于记录每个连通块顶点的个数
int ticket[maxn];//记录每个人的票数
int t;
int n, m, k = 0;
int u,v;
int cnt = 0;
int low[maxn];
int dfn[maxn];//记录这个点走没走过
int in[maxn];//记录属于哪一个强连通
stack<int> s;

void tarjan(int u){
    dfn[u]=low[u]=++k;
    s.push(u);
    for(int i=0;i<G1[u].size();i++){
        int v=G1[u][i];
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(!in[v])
            low[u]=min(low[u],dfn[v]);
    }
    if(low[u]==dfn[u]) {
        cnt++;
        num[cnt]=0;
        while(true) {
            int x=s.top(); s.pop();
            in[x]=cnt;
            num[cnt]++;
            if(x==u) break;
        }
    }
}
/**************************强连通模板******************************/
int vis1[maxn];//用来逆向dfs是记录点数
int dfs(int u){
    vis1[u]=true;
    int sum=0;
    for(int i=0;i<G2[u].size();i++){
        int v=G2[u][i];
        if(!vis1[v]) sum+=num[v]+dfs(v);
    }
    return sum;
}
void init(){
    k=0;cnt=0;
    for(int i=0;i<n;i++){
        G1[i].clear();
        G2[i].clear();
        vis[i]=0;
    }
    memset(vis,0,sizeof vis);
    memset(ticket,0,sizeof ticket);
    memset(dfn,0,sizeof dfn);
    memset(low,0,sizeof low);
    memset(in,0,sizeof in);
    memset(num,0,sizeof num);
    while(!s.empty()) s.pop();
}
int main(){
    // freopen("in.txt","r",stdin);
    scanf("%d",&t);
    for(int ca=1;ca<=t;ca++){
        init();
        scanf("%d%d",&n,&m);
        for(int i=0;i<m;i++){
            scanf("%d%d",&u,&v);
            G1[u].push_back(v);
        }
        for(int i=0;i<n;i++)
            if(!dfn[i]) tarjan(i);
        //将连通块之间逆向连接
        for(int i=0;i<n;i++){
            cout<<in[i]<<" ";
        }cout<<endl;
        for(int u=0;u<n;u++)
        for(int i=0;i<G1[u].size();i++)
        {
            int v=G1[u][i];
            int x=in[u], y=in[v];
            if(x!=y)
            {
                vis[x]++;
                G2[y].push_back(x);//建立连通块的逆图
            }
        }
        // for(int i=0;i<n;i++){
            // cout<<num[i]<<" ";
        // }cout<<endl;
        int Max=-1;
        for(int i=1;i<=cnt;i++){
            if(!vis[i]){ //入度为零的联通块
                memset(vis1,0,sizeof vis1);
                int sum=num[i]-1+dfs(i);
                ticket[i]=max(ticket[i],sum);
            }
            Max=max(Max,ticket[i]);
        }
        printf("Case %d: %d
",ca,Max);
        int x=1;
        for(int i=0;i<n;i++){
            if(ticket[in[i]]==Max){
                if(x) printf("%d",i),x=0;
                else printf(" %d",i);
            }
        }
        puts("");
    }
    return 0;
}
/*
Case 5: 3
2 3
Case 6: 3
0 1 2 3


*/