Kosaraju演算法一看這個名字很奇怪就可以猜到它也是一個根據人名起的演算法，它的發明人是S. Rao Kosaraju，這是一個在圖論當中非常著名的演算法，可以用來拆分有向圖當中的強連通分量。

背景知識

這裡有兩個關鍵詞，一個是有向圖，另外一個是強連通分量。有向圖是它的使用範圍，我們只能使用在有向圖當中。對於無向圖其實也存在強連通分量這個概念，但由於無向圖的連通性非常強，只需要用一個集合維護就可以知道連通的情況，所以也沒有必要引入一些演算法。

有向圖我們都瞭解，那麼什麼叫做強連通分量呢？強連通分量的英文是strongly connected components。這是一個很直白的翻譯，要理解它我們首先需要理解強連通的概念。在有向圖當中，如果兩個點之間彼此存在一條路徑相連

強連通分量一般是一張完整的圖的一個部分，比如下面這張圖當中的{1, 2, 3, 4}節點就可以被看成是一個強連通分量。

其實求解強連通分量的演算法並不止一種，除了Kosaraju之外還有大名鼎鼎的Tarjan演算法可以用來求解。但相比Tarjan演算法，Kosaraju演算法更加直觀，更加容易理解。

演算法原理

Kosaraju演算法的原理非常簡單，簡單到只有三個步驟：

1. 我們通過後序遍歷的方式遍歷整個有向圖，並且維護每個點的出棧順序
2. 我們將有向圖反向，根據出棧順序從大到小再次遍歷反向圖
3. 對於點u來說，在遍歷反向圖時所有能夠到達的v都和u在一個強連通分量當中

怎麼樣，是不是很簡單？

下面我們來詳細闡述一下細節，首先後序遍歷和維護出棧順序是一碼事。也就是在遞迴的過程當中當我們遍歷完了u這個節點所有連通的點之後，再把u加入序列。其實也就是u在遞迴出棧的時候才會被加入序列，那麼序列當中儲存的也就是每個點的出棧順序。

這裡我用一小段程式碼（python）演示一下，看完也就明白了。

popped = [] # 儲存出棧節點

def dfs(u):
    for v in Graph[u]:
        dfs(v)
        popped.append(u)

我們在訪問完了所有的v之後再把u加入序列，這也就是後序遍歷，和二叉樹的後序遍歷是類似的。

反向圖也很好理解，由於我們求解的範圍是有向圖，如果原圖當中存在一條邊從u指向v，那麼反向圖當中就會有一條邊從v指向u。也就是把所有的邊都調轉反向。

我們用上面的圖舉個例子，對於原圖來說，它的出棧順序我們用紅色筆標出。

也就是[6, 4, 2, 5, 3, 1]，我們按照出棧順序從大到小排序，也就是將它反序一下，得到[1, 3, 5, 2, 4, 6]。1是第一個，也就是最後一個出棧的，也意味著1是遍歷的起點。

我們將它反向之後可以得到：

我們再次從1出發可以遍歷到2，3， 4，說明{1, 2, 3, 4}是一個強連通分量。

怎麼樣，整個過程是不是非常簡單？

我們將這段邏輯用程式碼實現，也並不會很複雜。

// Cpp
// g 是原圖，g2 是反圖
void dfs1(int u) {
    vis[u] = true;
    for (int v : g[u])
        if (!vis[v])
            dfs1(v);
    s.push_back(u);
}

void dfs2(int u) {
    color[u] = sccCnt;
    for (int v : g2[u])
        if (!color[v])
            dfs2(v);
}

void kosaraju() {
    sccCnt = 0;
    for (int i = 1; i <= n; ++i)
        if (!vis[i])
            dfs1(i);
    for (int i = n; i >= 1; --i)
        if (!color[s[i]]) {
            ++sccCnt;
            dfs2(s[i]);
        }
}

# python
N = 7
graph, rgraph = [[] for _ in range(N)], [[] for _ in range(N)]
used = [False for _ in range(N)]
popped = []


# 建圖
def add_edge(u, v):
    graph[u].append(v)
    rgraph[v].append(u)


# 正向遍歷
def dfs(u):
    used[u] = True
    for v in graph[u]:
        if not used[v]:
            dfs(v)
    popped.append(u)


# 反向遍歷
def rdfs(u, scc):
    used[u] = True
    scc.append(u)
    for v in rgraph[u]:
        if not used[v]:
            rdfs(v, scc)
            
# 建圖，測試資料         
def build_graph():
    add_edge(1, 3)
    add_edge(1, 2)
    add_edge(2, 4)
    add_edge(3, 4)
    add_edge(3, 5)
    add_edge(4, 1)
    add_edge(4, 6)
    add_edge(5, 6)


if __name__ == "__main__":
    build_graph()
    for i in range(1, N):
        if not used[i]:
            dfs(i)

    used = [False for _ in range(N)]
    # 將第一次dfs出棧順序反向
    popped.reverse()
    for i in popped:
        if not used[i]:
            scc = []
            rdfs(i, scc)
            print(scc)

思考

演算法講完，程式碼也寫了，但是並沒有結束，仍然有一個很大的疑惑沒有解開。演算法的原理很簡單，很容易學會，但問題是為什麼這樣做就是正確的呢？這其中的原理是什麼呢？我們似乎仍然沒有弄得非常清楚。

這裡面的原理其實很簡單，我們來思考一下，如果我們在正向dfs的時候，u點出現在了v點的後面，也就是u點後於v點出棧。有兩種可能，一種可能是u點可以連通到v點，說明u是v的上游。還有一種可能是u不能連通到v，說明圖被分割成了多個部分。對於第二種情況我們先不考慮，因為這時候u和v一定不在一個連通分量裡。對於第一種情況，u是v的上游，說明u可以連通到v。

這時候，我們將圖反向，如果我們從u還可以訪問到v，那說明了什麼？很明顯，說明了在正向圖當中v也有一條路徑連向u，不然反向之後u怎麼連通到v呢？所以，u和v顯然是一個強連通分量當中的一個部分。我們再把這個結論推廣，所有u可以訪問到的，第一次遍歷時在它之前出棧的點，都在一個強連通分量當中。

如果你能理解了這一點，那麼整個演算法對你來說也就豁然開朗了，相信剩下的細節也都不足為慮了。

到這裡，整個演算法流程的介紹就算是結束了，希望大家都可以enjoy今天的內容。