强连通代码 - 详细

强连通定义

定义
在有向图G中，如果两个顶点间至少存在一条互相可达路径，称两个顶点强连通(strongly connected)。
如果有向图G的每两个顶点都强连通，称G是一个强连通图
非强连通图有向图的极大强连通子图，称为强连通分量(strongly connected components)。
求强连通子图有这么几个算法

1.kosaraju

过程
https://www.cnblogs.com/nullzx/p/6437926.html

#include <iostream>
#include <vector>
using namespace std;
const int MAX = 10000;
// 原图G
vector<int> G[MAX];
// 反向图G_t
vector<int> G_t[MAX];
int N, M, ds, ans;
// 给正序里每个点一个编号
// 强连通的点编号相邻
int time[MAX];

bool vis[MAX];

void dfs(int x)
{
    vis[x] = 1;
    for (auto e : G[x])
    {
        if (!vis[e])
            dfs(e);
    }
    time[++ds] = x;
    // cout << x << "  " << ds << endl;
}
int order[MAX];
void redfs(int x)
{
    vis[x] = 1;
    // ans是强连通分量的个数
    // 现在是正在求他的个数
    // 我们可以在这个过程中用ans作为一个标记
    // 为了之后可以求出每个强连通分量的结点
    order[x] = ans;
    for (auto e : G_t[x])
    {
        if (!vis[e])
            redfs(e);
    }
}
// 输出每个强连通分量
void orderdfs(int k)
{
    vis[k] = 1;
    cout << k << ' ';
    for (auto e : G[k])
    {
        // 保证他们之前的标记一样
        if (!vis[e] && (order[e] == order[k]))
        {
            orderdfs(e);
        }
    }
}
void kosaraju()
{
    // 第一次DFS 算出每个点的次序(编号)
    for (int i = 1; i <= N; i++)
    {
        if (!vis[i])
            dfs(i);
    }
    // 归零
    fill(vis, vis + MAX, 0);
    // cout << endl;
    // 根据正向DFS的次序确定遍历反向DFS的次序
    for (int i = N; i >= 1; i--)
    {
        // 正序里一个环 可能有路能走到别的环
        // 但反序中是相反的，正序里能走的，在反序里就不能走了
        // 所以就看REDFS多少次就可以判断出强连通的数量
        if (!vis[time[i]])
        {
            redfs(time[i]);
            ans++;
        }
    }
    // cout << endl;
    cout << ans << endl;

    // 输出强连通分量
    fill(vis, vis + MAX, 0);
    for (int i = 1; i <= N; i++)
    {
        // 每次调用都输出一个强连通分量
        if (!vis[i])
        {
            orderdfs(i);
            cout << endl;
        }
    }
}

int main()
{
    cin >> N >> M;
    for (int i = 1; i <= M; i++)
    {
        int x, y;
        cin >> x >> y;
        G[x].push_back(y);
        // 反向
        G_t[y].push_back(x);
    }

    kosaraju();

    return 0;
}