ccf 高速公路

问题描述

　　某国有n个城市，为了使得城市间的交通更便利，该国国王打算在城市之间修一些高速公路，由于经费限制，国王打算第一阶段先在部分城市之间修一些单向的高速公路。
　　现在，大臣们帮国王拟了一个修高速公路的计划。看了计划后，国王发现，有些城市之间可以通过高速公路直接（不经过其他城市）或间接（经过一个或多个其他城市）到达，而有的却不能。如果城市A可以通过高速公路到达城市B，而且城市B也可以通过高速公路到达城市A，则这两个城市被称为便利城市对。
　　国王想知道，在大臣们给他的计划中，有多少个便利城市对。

输入格式

　　输入的第一行包含两个整数n, m，分别表示城市和单向高速公路的数量。
　　接下来m行，每行两个整数a, b，表示城市a有一条单向的高速公路连向城市b。

输出格式

　　输出一行，包含一个整数，表示便利城市对的数量。

样例输入

5 5
1 2
2 3
3 4
4 2
3 5

样例输出

3

样例说明

　　城市间的连接如图所示。有3个便利城市对，它们分别是(2, 3), (2, 4), (3, 4)，请注意(2, 3)和(3, 2)看成同一个便利城市对。

评测用例规模与约定

前30%的评测用例满足1 ≤ n ≤ 100, 1 ≤ m ≤ 1000

前60%的评测用例满足1 ≤ n ≤ 1000, 1 ≤ m ≤ 10000；

所有评测用例满足1 ≤ n ≤ 10000, 1 ≤ m ≤ 100000。

解题关键：

求图中的强连通分量，对于每一个连通分量，节点对数为 n * ( n - 1) /2 （n > 1）.

有向图强连通分量：

在有向图G中，如果两个顶点Vi,Vj间有一条从Vi到Vj的有向路径，同时还有一条从Vj到Vi的有向路径，则称两个顶点强连通。如果有向图G的

每两个顶点都强连通，称G是一个强连通图。有向图的极大强连通子图，称为强连通分量。

求强连通分量的算法有三种：

1、Kosaraju算法：

首先对图G进行一次DFS，计算出各顶点完成搜索的时间f；然后计算图的逆向图 G T，对逆向图进行DFS，不过此次搜索时顶点的访问次序不是按

照顶点标号的大小，而是按照各顶点f值由大到小的顺序；逆向图DFS得到的森林即对应连通区域

#include <iostream>
#include <vector>
#include <string.h>
using namespace std;
#define N 10005

vector <int> edge[N], redge[N];//存放图、反向图
vector <int>time; //记录每个节点的离开时间
int vis[N];//标记节点是否被访问过
int belong[N], num[N]; //belong:每个节点所属的连通分量 num:统计每个连通分量中节点的个数
int id; //连通分量的个数

void Dfs1(int u) //记录dfs后各结点的结束时间
{
    vis[u] = 1;
    for(int i = 0; i < edge[u].size(); i ++)
    {
        int v = edge[u][i];
        if(!vis[v])
        {
            Dfs1(v);
        }
    }
    time.push_back(u);
}

void Dfs2(int u) //从time的尾部取出节点后, 对反向图进行dfs
{
    vis[u] = 1;
    belong[u] = id;
    num[id] ++;
    for(int i = 0; i < redge[u].size(); i ++)
    {
        int v = redge[u][i];
        if(!vis[v])
        {
            Dfs2(v);
        }
    }
}

int main()
{
    int n, m, a, b;
    cin >> n >> m;
    for(int i = 0; i < m; i++)
    {
        cin>> a >> b;
        edge[a].push_back(b);
        redge[b].push_back(a);
    }
    //第一遍dfs
    memset(vis, 0, sizeof(vis));
    for(int i = 1; i <= n; i++)
    {
        if(!vis[i]) Dfs1(i);
    }
    //第二遍dfs
    memset(vis, 0, sizeof(vis));
    memset(num, 0, sizeof(num));
    id = 0;
    for(int i = time.size() - 1; i >= 0; i--)
    {

        if(!vis[time[i]])
        {
            id ++;
            Dfs2(time[i]);
        }
    }
    //统计强连通的节点对数
    int sum = 0;
    for(int i = 1; i <= id; i++)
    {
        if(num[i] > 1) sum += num[i] * (num[i] -1) /2;
    }
    cout<<sum<<endl;
    return 0;
}

2、Tarjan算法

Tarjan算法 基于递归实现的深度优先搜索，在搜索过程中将顶点不断压入堆栈中，并在回溯时判断堆栈中顶点是否在同一联通分支。

函数借 助两个辅助数组DFN 和L ow，其中DFN [u]为 顶点u搜索的次序编号，L ow[u]为顶点u以及子树 能回溯到的最早的栈中 顶点的次序编号。

     

当DFN [u]=L ow[u]时，则 弹出栈中顶点并构成一个连通分支。

#include <iostream>
#include <vector>
#include <stack>
using namespace std;
#define N 10005

vector <int> edge[N];//图
int DFN[N];     //节点u搜索的次序编号(时间戳)
int Low[N];     //节点u或u的子树能够追溯到的最早的栈中节点的次序编号
int belong[N];  //每个节点所属的连通分量
int num[N];     //统计每个连通分量中节点的个数
int vis[N];     //标记节点是否被访问过
stack <int> st; //存放访问过的节点
int inStack[N]; //标记节点是否在栈中
int index = 0;  //当前次序编号
int id = 0;     //连通分量的个数

void dfs (int u)
{
    int v;
    DFN[u] = index;
    Low[u] = index;
    index ++;
    st.push(u);
    inStack[u] = 1;
    vis[u] = 1;

    for(int i = 0; i < edge[u].size(); i ++)
    {
        v = edge[u][i];
        if(!vis[v])
        {
            dfs(v);
            if(Low[u] > Low[v]) Low[u] = Low[v];
        }
        else if(inStack[v] && Low[u] > Low[v])
        {
             Low[u] = Low[v];
        }
    }

    if(Low[u] == DFN[u])
    {
        id ++;
        do
        {
            v = st.top();
            st.pop();
            inStack[v] = 0;
            belong[v] = id;
            num[id] ++;
        }
        while( u != v);
    }
}
int main()
{
    int n, m, a, b;

    cin >> n >>m;
    for(int i = 0; i < m; i ++)
    {
        cin >> a >> b;
        edge[a].push_back(b);
    }

   for(int i = 1; i <= n; i++)
    {
        if(!vis[i]) dfs(i);
    }

    int sum = 0;
    for(int i = 1; i <= id; i++)
    {
        if(num[i] > 1) sum += num[i] * (num[i] - 1) /2;
    }
    cout<<sum<<endl;
    return 0;
}