給定一個有向圖 G = (V, E)，對於任意一對頂點 u 和 v，有 u --> v 和 v --> u，亦即，頂點 u 和 v 是互相可達的，則說明該圖 G 是強連通的（Strongly Connected）。如下圖中，任意兩個頂點都是互相可達的。

對於無向圖，判斷圖是否是強連通的，可以直接使用深度優先搜尋（DFS）或廣度優先搜尋（BFS），從任意一個頂點出發，如果遍歷的結果包含所有的頂點，則說明圖是強連通的。

而對於有向圖，則不能使用 DFS 或 BFS 進行直接遍歷來判斷。如下圖中，如果從頂點 0 開始遍歷則可判斷是強連通的，而如果從其它頂點開始遍歷則無法抵達所有節點。

那麼，該如何判斷有向圖的強連通性呢？

實際上，解決該問題的較好的方式就是使用 強連通分支演算法（SCC：Strongly Connected Components） ，可以在  O(V+E) 時間內找到所有的 SCC。如果 SCC 的數量是 1，則說明整個圖是強連通的。

有向圖 G = (V, E) 的一個強連通分支是一個最大的頂點集合 C，C 是 V 的子集，對於 C 中的每一對頂點 u 和 v，有 u --> v 和 v --> u，亦即，頂點 u 和 v 是互相可達的。

實現 SCC 的一種演算法就是 Kosaraju 演算法 。Kosaraju 演算法基於深度優先搜尋（DFS），並對圖進行兩次 DFS 遍歷，演算法步驟如下：

1. 初始化設定所有的頂點為未訪問的；
2. 從任意頂點 v 開始進行 DFS 遍歷，如果遍歷結果沒有訪問到所有頂點，則說明圖不是強連通的；
3. 置換整個圖（Reverse Graph）；
4. 設定置換後的圖中的所有頂點為未訪問過的；
5. 從與步驟 2 中相同的頂點 v 開始做 DFS 遍歷，如果遍歷沒有訪問到所有頂點，則說明圖不是強連通的，否則說明圖是強連通的。

Kosaraju 演算法的思想就是，如果從頂點 v 可以抵達所有頂點，並且所有頂點都可以抵達 v，則說明圖是強連通的。

2. java原始碼

/**找到有向圖的強連通分支，正向遍歷，按照後根序壓棧，根據反向圖檢視結點是否可達*/
import java.util.*;
public class Kosaraju {
	
   static class Graph
   {
	   int n;
	   List<Integer>[] adj;
	   Graph(int n)
	   {
		   this.n=n;
		   this.adj=new List[n];
		   for(int i=0;i<n;i++)
		   {
			   this.adj[i]=new ArrayList<Integer>();
		   }
	   }
	   
	   public void addEdge(int v,int w)
	   {
		   this.adj[v].add(w);
	   }
	   
	   /**正向遍歷，以後根序壓棧，保證根先出棧*/
	   public void fillorder(int v,boolean[] visited,Stack<Integer> s)
	   {
		   visited[v]=true;
		   for(Integer i:this.adj[v])
		   {
			   if(!visited[i])
			   {
				   fillorder(i,visited,s);
			   }
		   }
		   s.push(v);
	   }
	   /**得到反向圖*/
	   public Graph getTranspose()
	   {
		  Graph gv=new Graph(this.n);
		  for(int i=0;i<n;i++)
		  {
			  for(Integer j:this.adj[i])
			  {
				  gv.adj[j].add(i);
			  }
		  }
		  return gv;
	   }
	   
	   /**DFS列印連通分支*/
	   public void DFSUtil(int v,boolean[] visited)
	   {
		   visited[v]=true;
		   System.out.print(v+" ");
		   for(Integer i:adj[v])
		   {
			   if(!visited[i])
			   {
				   DFSUtil(i,visited);
			   }
		   }
	   }
	   
	   /**按照Kosaraju演算法的步驟執行*/
	   public void printSCCs()
	   {
		   Stack<Integer> s=new Stack<Integer>();
		   boolean[] visited=new boolean[this.n];
		   for(int i=0;i<n;i++)
		   {
			   visited[i]=false;
		   }
		   /**後根序壓棧*/
		   for(int i=0;i<n;i++)
		   {
			   if(!visited[i])
			   {
				   fillorder(i,visited,s);
			   }
		   }
		   /**得到反向圖*/
		   Graph gr=this.getTranspose();
		   for(int i=0;i<n;i++)
		   {
			   visited[i]=false;
		   }
		   /**依據反向圖算可達性*/
		   while(!s.empty())
		   {
			   int v=s.pop();
			   if(visited[v]==false)
			   {
				   gr.DFSUtil(v, visited);
				   System.out.println();
			   }
			   
		   }
	   }
   }
   
   public static void main(String args[])
   {
	   Graph g=new Graph(5);
	   g.addEdge(1, 0);
	   g.addEdge(0, 2);
	   g.addEdge(2, 1);
	   g.addEdge(3, 0);
	   g.addEdge(3, 4);
	   g.printSCCs();
   }
   
  
}
 

3. 正確性證明

1. 第一次DFS有向圖G時，最後記錄下的節點必為最後一棵生成樹的根節點。 
證明：假設最後記錄下節點不是樹根，則必存在一節點為樹根，且樹根節點必為此節點祖先；而由後根序訪問可知祖先節點比此節點更晚訪問，矛盾；原命題成立

2. 第一次DFS的生成森林中，取兩節點A、B，滿足：B比A更晚記錄下,且B不是A的祖先(即在第一次DFS中，A、B處於不同的生成樹中)；則在第二次DFS的生成森林中，B不是A的祖先，且A也不是B的祖先(即在第二次DFS中，A、B處於不同的生成樹中)。 
證明：假設在第二次DFS的生成森林中，B是A的祖先，則反圖GT中存在B到A路徑，即第一次DFS生成森林中，A是B的祖先，則A必比B更晚記錄下，矛盾；假設在第二次DFS的生成森林中，A是B的祖先，則反圖GT中存在A到B路徑，即第一次DFS生成森林中，B是A的祖先,矛盾；原命題成立

3. 按上述步驟求出的必為強連通分量 
證明：首先，證明2保證了第二次DFS中的每一棵樹都是第一次DFS中的某棵樹或某棵樹的子樹。其次，對於第二次DFS中的每棵樹，第一次DFS保證了從根到其子孫的連通性，第二次DFS保證了根到子孫的反向連通性(即子孫到根的連通性)；由此，此樹中的每個節點都通過其根相互連通。

4. 演算法複雜度