模板 - 图论 - 强连通分量 - Kosaraju算法

这个算法是自己实现的Kosaraju算法，附带一个缩点，其实缩点这个跟Kosaraju算法没有什么关系，应该其他的强连通分量算法计算出每个点所属的强连通分量之后也可以这样缩点。

算法复杂度：
Kosaraju算法：初始化，加边，两次dfs，复杂度O(n+m)
强连通分量缩点算法：遍历每个点每条边，复杂度O(n+m)
对边排序去重：复杂度O(n+mlogm)

namespace SCC {
    const int MAXN = 1e6 + 5;

    int n;
    vector<int> G[MAXN], BG[MAXN];

    int c1[MAXN], cntc1;
    int c2[MAXN], cntc2;
    int s[MAXN], cnts;

    int n2;
    vector<int> V[MAXN];
    vector<int> G2[MAXN], BG2[MAXN];

    void init(int _n) {
        n = _n;
        cntc1 = 0, cntc2 = 0, cnts = 0;
        for(int i = 1; i <= n; ++i) {
            G[i].clear();
            BG[i].clear();
            c1[i] = 0;
            c2[i] = 0;
            s[i] = 0;
            V[i].clear();
            G2[i].clear();
            BG2[i].clear();
        }
    }

    void add_edge(int u, int v) {
        G[u].push_back(v);
        BG[v].push_back(u);
    }

    void dfs1(int u) {
        c1[u] = cntc1;
        for(int v : G[u]) {
            if(!c1[v])
                dfs1(v);
        }
        s[++cnts] = u;
    }

    void dfs2(int u) {
        V[cntc2].push_back(u);
        c2[u] = cntc2;
        for(int v : BG[u]) {
            if(!c2[v])
                dfs2(v);
        }
    }

    void Kosaraju() {
        for(int i = 1; i <= n; ++i) {
            if(!c1[i]) {
                ++cntc1;
                dfs1(i);
            }
        }

        for(int i = n; i >= 1; --i) {
            if(!c2[s[i]]) {
                ++cntc2;
                dfs2(s[i]);
            }
        }
    }

    void build() {
        n2 = cntc2;
        for(int i = 1; i <= n2; ++i) {
            for(auto u : V[i]) {
                for(auto v : G[u]) {
                    if(c2[v] != i) {
                        G2[i].push_back(c2[v]);
                        BG2[c2[v]].push_back(i);
                    }
                }
            }
        }

        for(int i = 1; i <= n2; ++i) {
            sort(G2[i].begin(), G2[i].end());
            G2[i].erase(unique(G2[i].begin(), G2[i].end()), G2[i].end());
            sort(BG2[i].begin(), BG2[i].end());
            BG2[i].erase(unique(BG2[i].begin(), BG2[i].end()), BG2[i].end());
        }
    }

    void solve() {

    }
}