【强连通分量分解】

摘自《挑战程序设计》4.3.1

【强连通分量分解原理】

　　对于一个有向图顶点的子集S，如果在S内任取两个顶点u和v，都能找到一条从u到v的路径，那么就称S是强连通的。如果在强连通的顶点集合S中加入其他任意顶点集合后，它都不再是强连通的，那么就称S是原图的一个强连通分量（SCC: Strongly Connected Component）。任意有向图都可以分解成若干不相交的强连通分量，这就是强连通分量分解。把分解后的强连通分量缩成一个顶点，就得到了一个DAG（有向无环图）。

　　强连通分量分解可以通过两次简单的DFS实现。

　　第一次DFS时，选取任意顶点作为起点，遍历所有尚未访问过的顶点，并在回溯前给顶点标号（post order，后序遍历）。对剩余的未访问过的顶点，不断重复上述过程。完成标号后，越接近图的尾部（搜索树的叶子），顶点的标号越小。

　　第二次DFS时，先将所有边反向，然后以标号最大的顶点为起点进行DFS。这样DFS所遍历的顶点集合就构成了一个强连通分量。之后，只要还有尚未访问的顶点，就从中选取标号最大的顶点不断重复上述过程。

　　正如前文所述，我们可以将强连通分量缩点并得到DAG。此时可以发现，标号最大的节点就属于DAG头部（搜索树的根）的强连通分量。因此，将边反向后，就不能沿边访问到这个强连通分量以外的顶点。而对于强连通分量内的其他顶点，其可达性不受边反向的影响，因此在第二次DFS时，我们可以遍历一个强连通分量里的所有顶点。

　　该算法只进行了两次DFS，因而总的复杂度是O(|V|+|E|)。

算法模板如下：

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
using namespace std;
const int MAX_V = 10005;
const int MAX_E = 50005;

int V; // 顶点数
vector<int> G[MAX_V];   // 图的邻接表表示
vector<int> rG[MAX_V];  // 把边反向后的图
vector<int> vs;         // 后序遍历顺序的顶点列表
bool used[MAX_V];       // 访问标记
int cmp[MAX_V];         // 所属强连通分量的拓扑序

void add_edge(int from, int to)
{
    G[from].push_back(to);
    rG[to].push_back(from);
}

void dfs(int v)
{
    used[v] = true;
    for (int i = 0; i < G[v].size(); i++)
    {
        if (!used[G[v][i]]) dfs(G[v][i]);
    }
    vs.push_back(v);
}

void rdfs(int v, int k)
{
    used[v] = true;
    cmp[v] = k;
    for (int i = 0; i < rG[v].size(); i++)
    {
        if (!used[rG[v][i]]) rdfs(rG[v][i], k);
    }
}

int scc()
{
    memset(used, 0, sizeof(used));
    vs.clear();
    for (int v = 0; v < V; v++)
    {
        if (!used[v]) dfs(v);
    }
    memset(used, 0, sizeof(used));
    int k = 0;
    for (int i = vs.size() - 1; i >= 0; i--)
    {
        if (!used[vs[i]]) rdfs(vs[i], k++);
    }
    return k;
}

【入门】POJ 2186 -- Popular Cows

题意：

　　每头牛都想成为牛群中的红人。给定N头牛的牛群和M个有序对(A, B)。(A, B)表示牛A认为牛B是红人。该关系具有传递性，所以如果牛A认为牛B是红人，牛B认为牛C是红人，那么牛A也认为牛C是红人。不过，给定的有序对中可能包含(A, B)和(B, C)，但不包含(A, C)。求被其他所有牛认为是红人的牛的总数。

分析：

　　考虑以牛为顶点的有向图，对每个有序对(A, B)连一条从 A到B的有向边。那么，被其他所有牛认为是红人的牛对应的顶点，也就是从其他所有顶点都可达的顶点。虽然这可以通过从每个顶点出发搜索求得，但总的复杂度却是O(NM)，是不可行的，必须要考虑更为高效的算法。

　　假设有两头牛A和B都被其他所有牛认为是红人。那么显然，A被B认为是红人，B也被A认为是红人，即存在一个包含A、B两个顶点的圈，或者说，A、B同属于一个强连通分量。反之，如果一头牛被其他所有牛认为是红人，那么其所属的强连通分量内的所有牛都被其他所有牛认为是红人。

　　由此，我们把图进行强连通分量分解后，至多有一个强连通分量满足题目的条件。而按前面介绍的算法进行强连通分量分解时，我们还能够得到各个强连通分量拓扑排序后的顺序，唯一可能成为解的只有拓扑序最后的强连通分量。所以在最后，我们只要检查这个强连通分量是否从所有顶点可达就好了。该算法的复杂度为O(N+M)，足以在时限内解决原题。

代码：

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
using namespace std;
const int MAX_V = 10005;
const int MAX_M = 50005;
int M, N;
int A[MAX_M], B[MAX_M];

vector<int>  G[MAX_V]; // 图的邻接表表示
vector<int> rG[MAX_V]; // 把边反向后的图
vector<int> vs;        // 后序遍历顺序的顶点列表
bool used[MAX_V];      // 访问标记
int SCC[MAX_V];        // 所属强连通分量的拓扑序
void add_edge(int from, int to)
{
     G[from].push_back(to);
    rG[to].push_back(from);
}
void dfs(int u) //第一次dfs，后序遍历标记，越靠近叶子结点标号越小
{
    used[u] = true;
    for(int i = 0; i < G[u].size(); i++)
    {
        int v = G[u][i];
        if(!used[v]) dfs(v);
    }
    vs.push_back(u);
}
void rdfs(int u, int k) //反向dfs，利用反向图，求出强连通分量个数
{
    used[u] = true;
    SCC[u] = k;
    for(int i = 0; i < rG[u].size(); i++)
    {
        int v = rG[u][i];
        if(!used[v]) rdfs(v, k);
    }
}

int scc()
{
    memset(used, 0, sizeof(used));
    vs.clear();
    for(int v = 0; v < N; v++)
        if(!used[v]) dfs(v);

    memset(used, 0, sizeof(used));
    int k = 0; //DAG结点个数
    for(int i = vs.size()-1; i >= 0; i--)
    {
        int v = vs[i];
        if(!used[v]) rdfs(v, k++);
    }
    return k;
}
void init()
{
    for(int i = 0; i < MAX_V; i++)
    {
         G[i].clear();
        rG[i].clear();
    }
}
int solve()
{
    for(int i = 0; i < M; i++)
    {
        add_edge(A[i]-1, B[i]-1);
    }
    int n = scc();

    int V = N;
    int u = 0, num = 0; //num为最末强连通分量中的结点个数
    for(int v = 0; v < V; v++)
    {
        if(SCC[v] == n-1)
        {
            u = v; num++;
        }
    }

    //检查是否所有点均可达u
    memset(used, 0, sizeof(used));
    rdfs(u, 0);  //从叶子结点往前搜索
    for(int v = 0; v < V; v++)
    {
        if(!used[v])
        {
            num = 0;
            break;
        }
    }
    return num;
}

int main()
{
    init();
    scanf("%d%d", &N, &M);
    for(int i = 0; i < M; i++)
    {
        scanf("%d%d", &A[i], &B[i]);
    }
    printf("%d
", solve());
    return 0;
}