洛谷 p2341 受欢迎的牛 （强连通分量）

题目描述
每头奶牛都梦想成为牛棚里的明星。被所有奶牛喜欢的奶牛就是一头明星奶牛。所有奶牛都是自恋狂，每头奶牛总是喜欢自己的。奶牛之间的“喜欢”是可以传递的——如果A喜欢B，B喜欢C，那么A也喜欢C。牛栏里共有N 头奶牛，给定一些奶牛之间的爱慕关系，请你算出有多少头奶牛可以当明星。

输入格式
第一行：两个用空格分开的整数：N和M

第二行到第M + 1行：每行两个用空格分开的整数：A和B，表示A喜欢B

输出格式
第一行：单独一个整数，表示明星奶牛的数量

输入输出样例
输入 #1复制
3 3
1 2
2 1
2 3
输出 #1复制
1
说明/提示
只有 3 号奶牛可以做明星

【数据范围】

10%的数据N<=20, M<=50
30%的数据N<=1000,M<=20000
70%的数据N<=5000,M<=50000
100%的数据N<=10000,M<=50000

思路： 先缩点，然后找到出度为0的点，如果只有一个出度为0的点，那么就输出这个强连通分量中所有牛的点，如果有多个出度为0的点，那么就没有明星牛。

#include<cstdio>
#include<algorithm>
#include<string>
#include<cstring>
#include<math.h>
#include<iostream>
#include<vector>
#include<set>
#include<stack>
#include<map>
#include<queue>
typedef unsigned long long ull;
typedef long long ll;
using namespace std;
const int N=1e5+5;
const int prime=2333317;
const int INF=0x3f3f3f3f3f;
int dfn[N],low[N],head[N],scc[N],sccing[N],out[N];
stack<int>s;
int k,n,dfs_clock,scc_clock,m;
struct node
{
    int v,next;
} edge[N];
void init()
{
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(head,-1,sizeof(head));
    memset(scc,0,sizeof(scc));
    memset(sccing,0,sizeof(sccing));
    memset(out,0,sizeof(out));
    k=dfs_clock=scc_clock=0;
}
void add(int u,int v)
{
    edge[k].v=v;
    edge[k].next=head[u];
    head[u]=k++;
}
void tarjan(int u)
{
    dfn[u]=low[u]=++dfs_clock;
    s.push(u);
    for(int i=head[u]; i!=-1; i=edge[i].next)
    {
        int v=edge[i].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(!scc[v])
            low[u]=min(low[u],dfn[v]);
    }
    if(low[u]==dfn[u])
    {
        scc_clock++;
        while(1)
        {
            int x=s.top();
            s.pop();
            scc[x]=scc_clock;
            sccing[scc_clock]++;
            if(u==x)
                break;
        }
    }
}
int main()
{
   scanf("%d%d",&n,&m);
    
        init();
        int x,y;
        for(int i=1; i<=m; i++)
        {
            scanf("%d%d",&x,&y);
            add(x,y);
        }
        for(int i=1; i<=n; i++)
        {
            if(!dfn[i])
                tarjan(i);
        }
        for(int u=1; u<=n; u++)
        {
            for(int j=head[u]; j!=-1; j=edge[j].next)
            {
                int v=edge[j].v;
                if(scc[u]!=scc[v])
                {
                    out[scc[u]]++;
                }
            }
        }
        int tt=0;
        for(int i=1; i<=scc_clock; i++)
            if(!out[i])
            {
                if(tt)
                {
                    puts("0");
                    return 0;
                }
                tt=i;
            }
        printf("%d\n",sccing[tt]);
        return 0;
}