hdu3639Hawk-and-Chicken

Hawk-and-Chicken

Time Limit : 6000/2000ms (Java/Other)   Memory Limit : 32768/32768K (Java/Other)

Total Submission(s) : 2   Accepted Submission(s) : 2

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

  
  

   
   2
4 3
3 2
2 0
2 1

3 3
1 0
2 1
0 2
  
  

 

Sample Output

  
  

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

 

题目大意： 很多人在投票，假如a喜欢b，那么a就投票给b，投票具有传递性，假如a投给b，b投给c 那么c就有2票了 最后问你最多得到多少票，输出得到这么多票的人。其实就是有多少人可以到达某个节点，且到达此节点的人数最多，可能存在多个节点具有相同的选票。

思路：刚开始缩点然后在DAG上求最长路，WA。然后细细分析一下，建立反图，然后找到所入度为零的节点，求可以到达节点的个数。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <stack>
#define DEBUG 10
using namespace std;
const int maxn = 5000+10;// vertex.
const int maxm = 30000+10; // edges.
int gn, gm;
//Accepted	3639	562MS	1508K	4225 B	G++	Achiberx
vector<int> G[maxn], G2[maxn];
vector<int> G3[maxn]; // reverse graph of G2.
vector<int> result[maxn];
bool vis[maxn]; // for dfs2.
int weight[maxn];// the number of vertex of every scc.
int pre[maxn], lowlink[maxn], sccno[maxn];
int dfs_clock, scc_cnt;
stack<int> S;

void dfs(int u) {
    pre[u] = lowlink[u] = ++dfs_clock;
    S.push(u);
    for(int i = 0; i < (int)G[u].size(); i++) {
        int v = G[u][i];
        if(!pre[v]) {
            dfs(v);
            lowlink[u] = min(lowlink[v], lowlink[u]);
        } else if(!sccno[v]) {
            lowlink[u] = min(lowlink[u], pre[v]);
        }
    }
    if(lowlink[u] == pre[u]) {
        scc_cnt++;
        for(;;) {
            int x = S.top(); S.pop();
            sccno[x] = scc_cnt;
            if(x == u) break;
        }
    }
}


void find_scc(int n) {
    dfs_clock = scc_cnt = 0;
    memset(sccno, 0, sizeof(sccno));
    memset(pre, 0, sizeof(pre));
    for(int i = 0; i < n; i++) { // from 0 to n-1.
        if(!pre[i]) dfs(i);
    }
}

void build_map() {
    memset(weight, 0, sizeof(weight));
    for(int i = 0; i < gn; i++) {
        int u = sccno[i];
        weight[u] += 1;
    }
    for(int i = 0; i < maxn; i++) { G2[i].clear(); G3[i].clear(); }
    for(int i = 0; i < gn; i++) {
        for(int j = 0; j < (int)G[i].size(); j++) {
            int v = G[i][j];
            if(sccno[i] != sccno[v]) {
                G2[sccno[i]].push_back(sccno[v]);
                G3[sccno[v]].push_back(sccno[i]);// reverse graph of G2.
            }
        }
    }
}

int dfs2(int u) {
    if(vis[u]) return 0;
    int total = 0;
    vis[u] = true;
    for(int i = 0; i < (int)G3[u].size(); i++) {
        int v = G3[u][i];
        total += dfs2(v);
    }
    if(!G3[u].size()) return weight[u];// leaf node.
    else return total + weight[u];
}

int main()
{
    freopen("in", "r", stdin);
    int T, cas = 0;
    int u, v; // for input.
    scanf("%d", &T);
    while(T--) {
        for(int i = 0; i < maxn; i++) G[i].clear();
        scanf("%d%d", &gn, &gm);
        for(int i = 0; i < gm; i++) {
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
        }
        find_scc(gn);
        build_map();
        for(int i = 0; i < maxn; i++) result[i].clear();
        for(int i = 1; i <= scc_cnt; i++) {
            if((int)G2[i].size() == 0) { // the outdegree equal 0 of G2.
                memset(vis, false, sizeof(vis));
                int amount = dfs2(i);
                result[amount-1].push_back(i);
            }
        }
        int maxv;
        for(int i = gn; i >= 0; i--) {
            if(result[i].size() != 0) {
                maxv = i;
                break;
            }
        }
        printf("Case %d: %d\n", ++cas, maxv);
        int Size = result[maxv].size();
        vector<int> V;
        V.clear();
        for(int i = 0; i < Size; i++) {
            for(int j = 0; j < gn; j++) {
                if(sccno[j] == result[maxv][i]) {
                    V.push_back(j);
                }
            }
        }
        sort(V.begin(), V.end());
        Size = V.size();
        if(Size==1) {
            printf("%d\n", V[0]);
        } else {
            for(int i = 0; i < Size-1; i++) {
                printf("%d ", V[i]);
            }
            printf("%d\n", V[Size-1]);
        }
    }
    return 0;
}