打印有向图的强连通分量-----kosaraju算法(最简单的实现)
一、kosaraju算法步骤：
1、首先对图G进行一次DFS,记录每个顶点完成的顺序(DFS树/林的叶子节点先完成，然后回溯到它双亲这一层，它个双亲递归遍历完自己的邻居并在这些递归完成回溯到这层后，它自己也完成了。
如这个图：假设从1开始DFS：
假设它的DFS生成树是这个：
那么各顶点的完成的顺序是：3,5,4,2,1
2、把图G所有的边方向，得到G',沿步骤1得到顺序，从最后完成那割顶点开始，再次对每个顶点(如果它没有被访问过)进行DFS,这样如果整个图不是一个强连通图，那就会得到一个DFS森林，其中每颗DFS生成树都是一个强连通分量。
例如上面图反向后：
按第一次对原图DFS遍历得到的各顶点的完成顺序相反的顺序，对反转后的图再次DFS,得到的就是这个森林:
二、证明：
http://www.personal.kent.edu/~rmuhamma/Algorithms/MyAlgorithms/GraphAlgor/strongComponent.htm
排版好差，我也看不懂。
三、代码：
1、图：
#include<iostream>
#include<list>
#include<stack>
#define NIL -1
using namespace std;
class Graph
{
int n;
list<int> *adj;
void getOrder(int u,bool visited[],stack<int> &stk);
void DFSUtil(int u, bool visited[]);
public:
Graph(int _n){ n = _n; adj = new list<int>[_n]; }
~Graph(){ delete [] adj; }
void addEdge(int v, int w){ adj[v].push_back(w); }
Graph getTranspose();
void printSCCs();
};
2、获得反向图：
Graph Graph::getTranspose() //有向图反向
{
Graph g(n);
list<int>::iterator it;
for(int i = 0; i < n; i++)
{
for(it = adj[i].begin(); it != adj[i].end(); it++)
{
g.addEdge(*it,i);
}
}
return g;
}
3、获得完成的顺序，因为在对反向图进行DFS的时候，是按完成顺序相反的顺序进行的，所以可以用栈进行存储，最先完成的会在栈底，最后完成的会在栈顶。
void Graph::getOrder(int u, bool visited[],stack<int>&stk)
{//对原图DFS,用栈记录完成顺序，最后完成的会在栈顶
visited[u] = true;
list<int>::iterator it;
for(it = adj[u].begin(); it != adj[u].end(); it++)
{
if(!visited[*it])
{
getOrder(*it, visited,stk);
}
}
stk.push(u); //完成后用栈记录
}
void Graph::DFSUtil(int u, bool visited[])
{
visited[u] = true;
cout<<u<<" "; //打印
list<int>::iterator it;
for(it = adj[u].begin(); it != adj[u].end(); it++)
{
if(!visited[*it])
{
DFSUtil(*it,visited);
}
}
}
void Graph::printSCCs()
{
bool *visited = new bool[n];
stack<int>stk;
for(int i = 0; i < n; i++)
{
visited[i] = false;
}
getOrder(0, visited, stk); //获得顺序
for(int i = 0; i < n; i++)
{
visited[i] = false;
}
Graph gr = getTranspose(); //获得反向的图
while(!stk.empty())
{//对反向图进行DFS,按于第一次DFS时各点完成访问相反的顺序进行
int v = stk.top();
stk.pop();
if(!visited[v])
{
gr.DFSUtil(v,visited);
cout<<endl; //用换行符分隔强连通分量
}
}
}
四、测试：
#include<iostream>
#include<list>
#include<stack>
#define NIL -1
using namespace std;
class Graph
{
int n;
list<int> *adj;
void getOrder(int u,bool visited[],stack<int> &stk);
void DFSUtil(int u, bool visited[]);
public:
Graph(int _n){ n = _n; adj = new list<int>[_n]; }
~Graph(){ delete [] adj; }
void addEdge(int v, int w){ adj[v].push_back(w); }
Graph getTranspose();
void printSCCs();
};
//获得反向图：
Graph Graph::getTranspose() //有向图反向
{
Graph g(n);
list<int>::iterator it;
for(int i = 0; i < n; i++)
{
for(it = adj[i].begin(); it != adj[i].end(); it++)
{
g.addEdge(*it,i);
}
}
return g;
}
//获得完成的顺序，因为在对反向图进行`DFS`的时候，是按完成顺序相反的顺序进行的，
//所以可以用栈进行存储，最先完成的会在栈底，最后完成的会在栈顶。
void Graph::getOrder(int u, bool visited[],stack<int>&stk)
{//对原图DFS,用栈记录完成顺序，最后完成的会在栈顶
visited[u] = true;
list<int>::iterator it;
for(it = adj[u].begin(); it != adj[u].end(); it++)
{
if(!visited[*it])
{
getOrder(*it, visited,stk);
}
}
stk.push(u); //完成后用栈记录
}
void Graph::DFSUtil(int u, bool visited[])
{
visited[u] = true;
cout<<u<<" "; //打印
list<int>::iterator it;
for(it = adj[u].begin(); it != adj[u].end(); it++)
{
if(!visited[*it])
{
DFSUtil(*it,visited);
}
}
}
void Graph::printSCCs()
{
bool *visited = new bool[n];
stack<int>stk;
for(int i = 0; i < n; i++)
{
visited[i] = false;
}
getOrder(0, visited, stk); //获得顺序
for(int i = 0; i < n; i++)
{
visited[i] = false;
}
Graph gr = getTranspose(); //获得反向的图
while(!stk.empty())
{//对反向图进行DFS,按于第一次DFS时各点完成访问相反的顺序进行
int v = stk.top();
stk.pop();
if(!visited[v])
{
gr.DFSUtil(v,visited);
cout<<endl; //用换行符分隔强连通分量
}
}
}
int main()
{
Graph g(5);
g.addEdge(0, 1);
g.addEdge(1, 2);
g.addEdge(1, 3);
g.addEdge(3, 4);
g.addEdge(4, 1);
g.addEdge(4, 2);
cout << "这个图的强连通分量是:"<<endl;
g.printSCCs();
return 0;
}
Tarjan算法