HDU 3639 Hawk-and-Chicken(强连通分量)

题目链接：

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

题意：

       给定一个n个小孩m个单向支持关系，问获得支持最多的小孩的编号，支持可以传递，例如a支持b，b支持c则c获得支持数为2，b为1，且对于一个有x个小孩的环内的每一个小孩来说，它从这个环内获得的支持数为环的小孩总个数减一，即获得除自己外其他小孩的支持(仅从环内获得支持数，暂时不考虑环外)。

分析：

       获得支持数最多的肯定是出度为0的强连通分量的中的所有小孩，然后出度为0的强连通分量可能有多个，所以就需要反向建图；首先求所有的强连通分量，然后缩点，根据这些点来反向建图，从开始判断的那些出度为0的强连通分量即点，开始搜索(dfs或bfs)，每遇到一个新节点即强连通分量，就把这个强连通分量里的点的个数加起来(对于刚开始的那个节点，即开始搜索的点，那么需要减去1)，然后就得到了该出度为0的强连通分量内小孩获得的支持数，然后求取这些出度为0的强连通的最大支持数，然后输出强连通分量内的小孩编号(升序)，如果有多个相同，则全输出

输出编号的时候一定要注意格式，最后一个数字后面不能出现空格，不然会PE；

代码：

#include<iostream>
#include<string>
#include<queue>
#include<set>
#include<vector>
#include<stack>
#include<map>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;

const int inf=0x7f7f7f7f;
const int maxn=5e4+50;
const int N=5e4+50;
typedef long long ll;
typedef struct{
    ll u,v,next,w;
}Edge;
Edge e[N],e1[N];

typedef struct B{
    int l,r;
    ll sum,lazy1,lazy2;
    void update(ll value1,ll value2){
        sum=sum*value1;
        lazy2=lazy2*value1;
        sum=(sum+(r-l+1)*value2);
        lazy1=(lazy1*value1+value2);
    }
}Tree;
Tree tree[4];
int cnt,head[N];
int cnt1,head1[N];
inline void add(int u,int v){
    e[cnt].u=u;
    e[cnt].v=v;
    //e[cnt].w=w;
    // e[cnt].f=f;
    e[cnt].next=head[u];
    head[u]=cnt++;
    // e[cnt].u=v;
    // e[cnt].v=u;
    // e[cnt].w=0;
    // e[cnt].f=-f;
    // e[cnt].next=head[v];
    // head[v]=cnt++;
}
inline void add1(int u,int v){
    e1[cnt1].u=u;
    e1[cnt1].v=v;
    e1[cnt1].next=head1[u];
    head1[u]=cnt1++;
}
inline int read()
{
    int x = 0;
    int f = 1;
    char c = getchar();
    while (c<'0' || c>'9')
    {    
        if (c == '-')
            f = -1;
        c = getchar();
    }
    while (c >= '0'&&c <= '9')
    {
        x = x * 10 + c - '0';
        c = getchar();
    }
    return x*f;
}

int T,res,n ,m,t,low[N],dfn[N],_time,vis[N],_scc[N],in[N],out[N],num[N],supp[N];
stack<int >s;
void tarjan(int u){
    low[u]=dfn[u]=++_time;
    s.push(u);
    vis[u]=1;
    for(int i=head[u];i!=-1;i=e[i].next){
        int v=e[i].v;
        if(!dfn[v]){
            tarjan(v);
            low[u]=min(low[v],low[u]);
        }
        else if(vis[v])low[u]=min(low[u],dfn[v]);
    }
    if(dfn[u]==low[u]){
        res++;
        do{
            t=s.top();
            s.pop();
            vis[t]=0;
            _scc[t]=res;
            num[res]++;
        }while(t!=u);
    }

}

int bfs(int x){
    int ans=0;
    memset(vis,0,sizeof(vis));
    queue<int >q;
    q.push(x);
    vis[x]=1;
    while(!q.empty()){
        int u=q.front();q.pop();
        //这个地方多谢了一局"vis[u]=0;"然后wa了,结果就是找了一个晚上= =才发现;
        for(int i=head1[u];i!=-1;i=e1[i].next){
            int v=e1[i].v;
            //cout<<u<<" "<<v<<" "<<i<<endl;
            if(!vis[v]){
                ans+=num[v];
                q.push(v);
                vis[v]=1;
            }
        }
    }
    return ans;
}
int main() {
    cin>>T;
    for(int k=1;k<=T;k++){
        scanf("%d%d",&n,&m);
        cnt1=cnt=res=_time=0;
        int a,b;
        memset(dfn,0,sizeof(dfn));
        memset(head,-1,sizeof(head));
        memset(head1,-1,sizeof(head1));
        memset(in,0,sizeof(in));
        memset(out,0,sizeof(out));
        memset(vis,0,sizeof(vis));
        memset(supp,0,sizeof(supp));
        memset(num,0,sizeof(num));
        for(int i=0;i<m;i++){
            scanf("%d%d",&a,&b);
            add(a,b);
        }
        while(!s.empty())s.pop();
        for(int i=0;i<n;i++)
            if(!dfn[i])
                tarjan(i);
        //cout<<res<<endl;
        for(int i=0;i<cnt;i++){
            int u=e[i].u,v=e[i].v;
            if(_scc[u]!=_scc[v]){
                out[_scc[u]]++;
                in[_scc[v]]++;
                add1(_scc[v],_scc[u]);
            }      
        }
        /*for(int i=0;i<n;i++){
            cout<<i<<" "<<_scc[i]<<endl;
        }*/
        int maxm=-1;
        for(int i=1;i<=res;i++){
            if(out[i]==0){
                supp[i]=bfs(i)+num[i]-1;
                //cout<<supp[i]<<endl;
                maxm=max(maxm,supp[i]);
            }
        }
        //if(res==1) maxm--;
        cout<<"Case "<<k<<": "<<maxm<<endl;
        int j=0;
        for(j=0;j<n;j++){
            if(maxm==supp[_scc[j]]){
                cout<<j++;
                break;
            }
        }
        for(;j<n;j++)
            if(maxm==supp[_scc[j]])
                cout<<" "<<j;
        cout<<endl;
    }
    return 0;
}   

(仅供个人理解)