Tarjan算法应用：统计有向图中的强连通分量

        有向图中的强连通分量是指，任何两个顶点都能相互到达的子图。

有向图中的Tarjan算法步骤：  

        1、构建一个有向图；一个时间戳数组dfn[]，表示遍历的次序；一个回溯点数组low[]，表示能通过非父子边回溯到的最早结点遍历序号；

        2、将一个根节点传入函数，初始时：dfn = low = 次序，

        3、将根节点入栈并标记；

        4、遍历邻接点，若邻接点未被访问，递归，递归后更新low值；若邻接点已经访问且在栈中，说明之间有有向非父子边相连，更新low值。

强连通分量判定：

        在Tarjan算法中，x的邻接点都遍历完毕时，判断如果low[x] = dfn[x]，则从栈中不断弹出结点，直到x出栈停止；弹出的所有结点就是同一个连通分量的所有成员，可以标记这些结点的强联通分量号。

强连通分量缩点的出度和入度

        建立出度入度数组，用强连通分量号作为下标，内容为其缩点的出度和入度，遍历全部结点，若有其邻接点的连通分量号不同，其缩点的出入+1，邻接点对应强连通分量缩点的入度+1。

代码实现：

#include <iostream>
using namespace std;
#include <stack>
#define maxn 100

int m, n;   //边数、结点数
int head[maxn], cnt;
int dfn[maxn], low[maxn], num;  //时间戳数组、回溯点数组
int out_degree[maxn], in_degree[maxn];   //缩点的出度
stack<int> s;
int belong[maxn],id;
bool ins[maxn];

class Edge
{
public:
    int to;
    int next;
};
Edge edge[maxn << 1];

void InsertEdge(const int& u, const int& v)
{
    edge[++cnt].to = v;
    edge[cnt].next = head[u];
    head[u] = cnt;
}

void CreateGraph()
{
    int u, v;
    cout << "请输入结点数：" << endl;
    cin >> n;
    cout << "请输入边数：" << endl;
    cin >> m;
    cout << "请依次输入每个边的两个顶点：" << endl;
    for (int i = 1; i <= m; i++)
    {
        cin >> u >> v;
        InsertEdge(u, v);
    }
}

void Tarjan(int u)
{
    dfn[u] = low[u] = ++num;
    s.push(u);
    ins[u] = true;
    for (int i = head[u]; i; i = edge[i].next)
    {
        int v = edge[i].to;
        if (!dfn[v])
        {
            Tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if (ins[v])
        {
            low[u] = min(low[u], dfn[v]);
        }
    }
    if (low[u] == dfn[u])
    {
        int v = 0;
        ++id;
        do
        {
            v = s.top();
            s.pop();
            belong[v] = id;
            ins[v] = false;
        } while (v != u);
    }
}

int main()
{
    CreateGraph();
    for (int i = 1; i <= n; i++)
    {
        if (!dfn[i])
        {
            Tarjan(i);
        }
    }
    for (int u = 1; u <= n; u++)
    {
        for (int i = head[u]; i; i = edge[i].next)
        {
            int v = edge[i].to;
            if (belong[u] != belong[v])
            {
                out_degree[belong[u]]++;
                in_degree[belong[v]]++;
            }
        }
    }
    cout << "一共有" << id << "个缩点" << endl;
    for (int i = 1; i <= id; i++)
    {
        cout << "第" << i << "个缩点 入度为：" << out_degree[i] << "  出度为：" << in_degree[i] << endl;
    }

    return 0;
}