hdu 3639 强连通练习使用

题意很明显，就是说现在有n个孩子正在玩游戏，完成一个传递的游戏，举个例子，A传递到B小朋友，然后B小朋友传递给C小朋友，那么此时，C小朋友将拥有2的传递值，C是胜利者，若C又传递回A，那么A,B,C三者都拥有传递值为2的胜利者，说白了就是强连通的一个练习。

思路就是分清楚这整个图当中的强连通分量，每个分量包含了哪些点，将这些分量缩成一个点，然后建立这些点的一个反向图，然后每次从入度为0的强连通分量深搜，最后标记哪些强连通分量为max。那么只要该点所属的强连通分量为max，那么该点，也就是该小朋友就是赢家。。

　　#include<iostream>
　　#define min(a,b) a<b?a:b
　　#define max(a,b) a>b?a:b
　　using namespace std;
　　struct node
　　{
　　    int s,e,next;       
　　}edge1[500002],edge2[500002];
　　int head1[5002],head2[5002],dfn[5002],low[5002],stack[5002],exsit[5002],weight[5002],color[5002],n,m,s,e,top,Count,Time;
　　int ind[5002],Max,sum;
　　void tarjan(int u)
　　{
　　     dfn[u]=low[u]=++Time;
　　     stack[top++]=u;
　　     exsit[u]=1;
　　     for(int end=head1[u];end!=-1;end=edge1[end].next)
　　     {
　　          if(!dfn[edge1[end].e])
　　          {
　　              tarjan(edge1[end].e);
　　              low[u]=min(low[u],low[edge1[end].e]);
　　          }
　　          else
　　           if(exsit[edge1[end].e]==1)
　　           low[u]=min(low[u],dfn[edge1[end].e]);
　　     }
　　     if(dfn[u]==low[u])
　　     {
　　         Count++;
　　         int v;
　　         do
　　         {
　　             v=stack[top-1];
　　             exsit[v]=0;
　　             weight[v]=Count;
　　             color[Count]++;
　　             top--;
　　         }while(u!=v);
　　         
　　     }
　　}
　　void dfs(int i)
　　{
　　    sum+=color[i];
　　    exsit[i]=1;
　　    Max=max(Max,sum);
　　    for(int j=head2[i];j!=-1;j=edge2[j].next)
　　    {
　　          if(exsit[edge2[j].e]==0)
　　          {
　　             dfs(edge2[j].e);                   
　　          }
　　    }
　　    return ;
　　}
　　int main()
　　{
　　   int t,T=0;
　　   scanf("%d",&t);
　　   while(t--)
　　   {
　　          scanf("%d%d",&n,&m);
　　          for(int i=0;i<=n;i++)
　　          {
　　               head1[i]=head2[i]=-1;
　　               color[i]=weight[i]=exsit[i]=dfn[i]=low[i]=0;
　　          }
　　          for(int i=0;i<m;i++)
　　          {
　　              scanf("%d%d",&s,&e);
　　              edge1[i].s=s;
　　              edge1[i].e=e;
　　              edge1[i].next=head1[s];
　　              head1[s]=i;
　　          }
　　          Time=top=Count=0;
　　          for(int i=0;i<n;i++)
　　          {
　　              if(!dfn[i])
　　              {
　　                tarjan(i);
　　              }
　　          }
　　          for(int i=1;i<=Count;i++)
　　          {
　　             dfn[i]=ind[i]=0;
　　          }
　　          Time=0;
　　          for(int i=0;i<m;i++)
　　          {
　　                int start=weight[edge1[i].s];
　　                int end=weight[edge1[i].e];
　　                if(start!=end)
　　                {
　　                      edge2[Time].e=start;
　　                      edge2[Time].next=head2[end];
　　                      head2[end]=Time++;
　　                      ind[start]++;
　　                }
　　          }
　　          int maxsize=0;
　　          for(int i=1;i<=Count;i++)
　　          {
　　             
　　             if(ind[i]==0)
　　             {
　　               for(int j=1;j<=Count;j++)exsit[j]=0;
　　               Max=sum=0;
　　               dfs(i);
　　               dfn[i]=Max;
　　               maxsize=max(dfn[i],maxsize);
　　             }
　　          }
　　          int flag=0;
　　          printf("Case %d: %d\n",++T,maxsize-1);
　　          for(int i=0;i<n;i++)
　　          {
　　             if(dfn[weight[i]]==maxsize)
　　             {
　　                 if(!flag){printf("%d",i);flag=1;}
　　                 else
　　                 printf(" %d",i);
　　             }        
　　          }
　　          printf("\n");
　　   }
　　   return 0;
　　}