【POJ2186】Popular Cows 有向图强连通分量详解（再水一篇怕被骂、、所以。。）

本文链接：https://blog.csdn.net/dont_crytat/article/details/54409898

很多人跟我说的是，我裤子都脱了，你就给我看前面几篇文章？
好吧，好吧，我比较仁慈
这次就来个高大上点的
说一下有向图强连通分量。。。

有向图强连通分量是个嘛子啊（虽然博主是个东北人）

有向图强连通分量：在有向图G中，如果两个顶点vi,vj间（vi>vj）有一条从vi到vj的有向路径，同时还有一条从vj到vi的有向路径，则称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。有向图的极大强连通子图，称为强连通分量(strongly connected components)。

博主很懒，上段的定义我坦白是摘自百度百科，很好理解吧，这里就不细讲了

下图中，子图{1,2,3,4}为一个强连通分量，因为顶点 1,2,3,4 两两可达。{5},{6}也分别是两个强连通分量
这里写图片描述

那么下面讲一下求有向图强连通分量的Tarjan算法（%Tarjan大佬）

Tarjan 算法是基于对图深度优先搜索(DFS)的算法，每个强连通分量为搜索树中的一棵子树（的一部分）。搜索时，把当前搜索树中未处理的结点加入一个栈，回溯时可以判断栈顶到栈中的结点是否为一个强连通分量。
DFS 过程中遇到的四种边：
1.树枝边：DFS 时经过的边，即 DFS 搜索树上的边
2.前向边：与 DFS 方向一致，从某个结点指向其某个子孙的边
3.后向边：与 DFS 方向相反，从某个结点指向其某个祖先的边
4.横叉边：从某个结点指向搜索树中另一子树中的某结点的边
定义 DFN(u)为结点 u 搜索的次序编号(时间戳)，Low(u)为 u 或 u 的子树（经过最多一条后向边或栈中横叉边）（也就是，他只能走一次后向边或栈中横叉边）能够回溯到的最早的栈中结点的次序号。
由定义可以得出:
Low(u)=Min
{
DFN(u),
Low(v),(u,v)为树枝边，u 为 v 的父结点
DFN(v),(u,v)为后向边或指向栈中结点的横叉边
}
当结点 u 的搜索过程结束后，若 DFN(u)=Low(u) ，则以 u 为根的搜索子树上所有还在栈中的结点是一个强连通分量。

伪代码如下：

procedure tarjan(u)
{
    DFN[u]=Low[u]=++Index    // 为结点 u 设定次序编号和 Low 初值
    Stack.push(u)            // 将结点 u 压入栈中
    for each (u, v) in E     // 枚举每一条边
    if (v is not visted)     // 如果结点 v 未被访问过
    tarjan(v)                // 继续向下找
    Low[u] = min(Low[u], Low[v])
    else if (v in S)         // 如果结点 v 还在栈内
    Low[u] = min(Low[u], DFN[v])
    if (DFN[u] == Low[u])    // 如果结点 u 是强连通分量的根
    repeat
    v = S.pop                // 将 v 退栈，为该强连通分量中一个顶点
    print v
    until (u== v)
}

不过有些时候，我们就是分不清，啥时候是用儿子的low去更新父亲的low还是用儿子的dfn去更新low，其实博主想了很久，想到了一个方法，如果“儿子”还没被访问过，那么儿子的low可能会更优（及回到更早）这是用儿子的low去更新，而儿子被搜过呢（也可以说在这个点之前就被搜过了，此时搜到的是一条后向边或栈中横叉边），由于之前low的定义，所以u只能走到“儿子”的dfn，所以用dfn去更新。

下面是一道裸的有向图强连通分量题，poj2186的明星奶牛（popular cows）
题目大意：每一头牛的愿望就是变成一头最受欢迎的牛。现在有N头牛，给你M对整数(A,B)，表示牛A认为牛B受欢迎。这种关系是具有传递性的，如果A认为B受欢迎，B认为C受欢迎，那么牛A也认为牛C受欢迎。你的任务是求出有多少头牛被所有的牛认为是受欢迎的。

解题思路：先用tarjan求出每个强连通分量，再缩点，统计每个点的出度，如果有且只有1个出度为0的点，就输出这个点包含的节点数，否则输出0
ps：缩点的话，个人觉得是在tarjan里很常见的，就是吧一个强连通分量看成一个点，这样最后形成的就是有向无环图
我们不是已经讲每个强连通分量放到了属于自己的belong里了嘛？只需要记录着每个强连通分量所属belong向外连了几条边就好了。

下面是代码（博主的代码可能很鬼畜）

#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std;
int time,n,m,x,y,ans,top,i,j,tot;
int sure[1000][1000];
int next[400005],to[400005],head[400005],dfn[400005],low[400005],cal[400005];
int in[400005],stack[400005],belong[400005],check[400005],b[400005],vis[400005],outcome[400005];
void add(int x,int y)
{
    tot++;
    next[tot]=head[x];
    to[tot]=y;
    head[x]=tot;
}
void dfs(int u)
{
    in[u]=1;
    stack[++top]=u;
    low[u]=dfn[u]=++time;
    for(int now=head[u];now;now=next[now]) 
    {
        int v=to[now];
        if (dfn[v]==0)
        {
            dfs(v);
            low[u]=min(low[u],low[v]);
        }
        else if (in[v]==1)
        {
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(dfn[u]==low[u])
    {
        int hh;
        do
        {
            hh=stack[top--];
            belong[hh]=ans;
            check[ans]++;
            in[hh]=0;
        }while(hh!=u);
        ans++;
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    tot=0;
    for(i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);
        add(x,y);
    }
    for(i=1;i<=n;i++)
    {
        if (dfn[i]==0) dfs(i);
    }
    /*int sum=0;
    for(i=0;i<ans;i++)
    {
        if (check[i]!=1)
            sum++;
    }*/ 
    for(i=1;i<=n;i++)
    {
        for(int now=head[i];now;now=next[now])
        {
            if (belong[i]!=belong[to[now]])
            {
                outcome[belong[i]]++;
            }
        }
    }
    int hh=0;
    int p;
    for(i=0;i<ans;i++)
    {
        if (outcome[i]==0)
        {
            hh++;
            p=i;
        }
    }
    if (hh!=1)
    {
        printf("0\n");
    }
    else 
    {
        printf("%d\n",check[p]);
    }
    return 0;
}