hdu3639 强联通＋dfs

题意：求有向图中能够到达该节点的点的数量是多少

解法：先进行强联通处理出联通分量 然后对反图进行缩点 则可以得到一个相反的DAG

         然后对每个入度为0的点进行dfs 同时累加dfs树上的权值 然后就可以到达每个点的

         答案，最后进行一下判定就可以了

#pragma comment(linker,"/STACK:102400000,102400000")
#include <iostream>
#include <string.h>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <string>
#include <math.h>
#include <queue>
#include <stack>
#include <map>
#include <set>
using namespace std;
typedef long long ll;   //记得必要的时候改成无符号
const int maxn=100005;   //点数
const int maxm=500005;   //边数
const int INF=100005555;
int scan()
{
    int res=0,ch;
    while(!((ch= getchar())>='0'&&ch<='9')){
        if(ch==EOF)return 1<<30;
    }
    res=ch-'0';
    while((ch=getchar())>='0'&&ch<='9')
        res=res*10+(ch-'0');
    return res;
}
vector<int>rg[maxn];
struct EdgeNode
{
    int from;
    int to;
    int next;
}edge[maxm];
int head[maxn],cnt;
void add(int x,int y)
{
    edge[cnt].from=x;edge[cnt].to=y;
    edge[cnt].next=head[x];head[x]=cnt++;
}

void init()
{
    cnt=1;
    memset(head,-1,sizeof(head));
}

int dfn[maxn],low[maxn],ins[maxn];
int cixu,scc_count,n,ru[maxn],chu[maxn],sd[maxn];
stack<int>S;
int value[maxn];
void dfs(int u)
{
    int v,x;
    dfn[u]=low[u]=++cixu;
    S.push(u);
    ins[u]=1;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(!dfn[v]){
            dfs(v);
            low[u]=min(low[u],low[v]);
        }
        else if(ins[v])
            //如果已经搜过，并且在栈里面，如果不在栈里面，说明该点属于其他的强连通分量里面
            low[u]=min(low[u],dfn[v]);
        //此处low代替dfn也是可以的，但是在tarjan求无向图的时候不能
    }
    if(dfn[u]==low[u])
        //表示u为此强连通分量第一个被发现的点，属于该强连通分量的所有的其他点都在栈中，他的上面
    {
        scc_count++;
        do
        {
            x=S.top();
            S.pop();
            sd[x]=scc_count;
            value[scc_count]++;
            ins[x]=0;
        }while(x!=u);
    }
}
int cc[maxn];
void tarjan()
{
    for(int i=1;i<=n;i++)sd[i]=i;   //缩点标记数组
    memset(ins,0,sizeof(ins));
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    cixu=scc_count=0;
    for(int i=1;i<=n;i++)        //可能所给的图为不连通的图，分块，因此需要遍历所有的点
    {
        if(!dfn[i])
            dfs(i);
    }
}
int vis[maxn],sum;
// scc_count 1...
void rdfs(int u){
    vis[u]=1;
    for(int i=0;i<rg[u].size();++i){
        int v=rg[u][i];
        if(!vis[v]){
            sum+=value[v];
            cc[u]+=cc[v];
            rdfs(v);
        }
    }
}
vector<int>eminem;
int main()
{
    int m,i,p,x,y,cas=1;
    int _;scanf("%d",&_);
    while(_--){
        scanf("%d%d",&n,&m);
        memset(cc,0,sizeof cc);
        init(); sum=0; p=0;
        for(i=1;i<=m;i++){
            x=scan();y=scan();
            ++x;++y;
            add(x,y);
        }
        memset(value,0,sizeof value);
        tarjan();
        memset(ru,0,sizeof ru);
        for(int i=1;i<=n;++i)
            for(int j=head[i];j!=-1;j=edge[j].next){
                int v=edge[j].to;
                if(sd[i]!=sd[v]){
                    rg[sd[v]].push_back(sd[i]);
                    ru[sd[i]]++;
                }
            }
        
        int ma=-1;
        for(int i=1;i<=scc_count;++i)
            if(ru[i]==0){
                sum=0;
                memset(vis,0,sizeof vis);
                rdfs(i);
                sum+=value[i]-1;
                cc[i]=sum;
                ma=max(sum,ma);
            }
        printf("Case %d: %d\n",cas++,ma);
        memset(vis,0,sizeof vis);
        for(int i=1;i<=scc_count;++i)
            if(ma==cc[i]){
                vis[i]=1;
            }
        
        eminem.clear();
        for(int i=1;i<=n;++i)
            if(vis[sd[i]]){
                eminem.push_back(i);
            }
        for(vector<int>::iterator it=eminem.begin();it!=eminem.end();it++)
            printf(it==eminem.begin()?"%d":" %d",*it-1);
        for(int i=1;i<=n;++i)rg[i].clear();
        printf("\n");
    }
    return 0;
}