CCF計算機職業資格認證考試題解系列文章為meelo原創，請務必以鏈接形式注明本文地址

CCF CSP 201709-4 通信網絡

問題描述

　　某國的軍隊由 N個部門組成，為了提高安全性，部門之間建立了 M條通路，每條通路只能單向傳遞信息，即一條從部門 a到部門 b的通路只能由 a向 b傳遞信息。信息可以通過中轉的方式進行傳遞，即如果 a能將信息傳遞到 b， b又能將信息傳遞到 c，則 a能將信息傳遞到 c。一條信息可能通過多次中轉最終到達目的地。
　　由於保密工作做得很好，並不是所有部門之間都互相知道彼此的存在。只有當兩個部門之間可以直接或間接傳遞信息時，他們才彼此知道對方的存在。部門之間不會把自己知道哪些部門告訴其他部門。

　　上圖中給了一個4個部門的例子，圖中的單向邊表示通路。部門1可以將消息發送給所有部門，部門4可以接收所有部門的消息，所以部門1和部門4知道所有其他部門的存在。部門2和部門3之間沒有任何方式可以發送消息，所以部門2和部門3互相不知道彼此的存在。
　　現在請問，有多少個部門知道所有 N個部門的存在。或者說，有多少個部門所知道的部門數量（包括自己）正好是 N。

輸入格式

　　輸入的第一行包含兩個整數 N,  M，分別表示部門的數量和單向通路的數量。所有部門從1到 N標號。
　　接下來 M行，每行兩個整數 a,  b，表示部門 a到部門 b有一條單向通路。

輸出格式

　　輸出一行，包含一個整數，表示答案。

樣例輸入

4 4
1 2
1 3
2 4
3 4

樣例輸出

2

樣例說明

　　部門1和部門4知道所有其他部門的存在。

評測用例規模與約定

　　對於30%的評測用例，1 ≤  N ≤ 10，1 ≤  M ≤ 20；
　　對於60%的評測用例，1 ≤  N ≤ 100，1 ≤  M ≤ 1000；
　　對於100%的評測用例，1 ≤  N ≤ 1000，1 ≤  M ≤ 10000。

解析

如果圖無環，計算每一個頂點父節點的個數及子節點的個數，如果二者之和加一等於總節點的個數，那么就是所求解的知道N個節點存在的節點。

統計一個節點父節點的個數可以通過N個深度優先搜索得到。從每一個節點開始進行深度優先搜索，每到達一個節點，該節點的計數加一。復雜度為O(V(V+E))

將圖的所有邊反向，便可以統計一個節點子節點的個數。

如果圖存在環，在同一個強連通分量內的節點互相為父子節點，上面的方法便失效了。解決方案是首先進行強連通分量的分解。代碼中使用了Kosaraju算法進行強連通分量的分解。復雜度為O(V+E)

分解后得到每一個頂點的強連通分量標號。

然后計算每一個節點父強連通分量的個數與子強連通分量的個數。這一步從每一個強連通分量中選擇一個頂點開始進行深度優先搜索，如果當前所在強連通分量的標簽與起始節點強連通分量標簽不同，則該節點計數加一。

如果一個頂點父強連通分量的個數加上子強連通分量的個數加一等於總強連通分量個數，那么這個節點知道所有節點的存在。

代碼

C++

#include <iostream>
#include <vector>
#include <algorithm>
#define MAX_V 1001
using namespace std;

int N, M;
vector<int> G[MAX_V], rG[MAX_V];
vector<int> postorder;
bool used[MAX_V];
int label[MAX_V]; // 每一個節點所屬強連通分量的標號
int sccv[MAX_V]; // 每一個強連通分量的一個頂點
int nparent[MAX_V], nchild[MAX_V];  // 每一個節點父/子強連通分量個數 

// 生成圖的后序遍歷 
void dfs(int u) {
    for(int i=0; i<G[u].size(); i++) {
        int v = G[u][i];
        if(!used[v]) {
            used[v] = true;
            dfs(v);
        }
    }
    postorder.push_back(u);
}

int rdfs(int u, int l) {
    label[u] = l;
    for(int i=0; i<rG[u].size(); i++) {
        int v = rG[u][i];
        if(!used[v]) {
            used[v] = true;
            rdfs(v, l);
        }
    }
}

// Kosaraju算法 分解強連通分量 
int SCC() {
    fill(used, used+MAX_V, 0);
    for(int n=1; n<=N; n++) {
        if(!used[n]) {
            used[n] = true;
            dfs(n);
        }
    }
    fill(used, used+MAX_V, 0);
    int l = 0;
    for(int n=N-1; n>=0; n--) {
        int v = postorder[n];
        if(!used[v]) {
            l++;
            used[v] = true;
            rdfs(v, l);
            sccv[l] = v;
        }
    }
    return l;
}

// 統計u所在強連通分量能夠到達的其它強連通分量 
void dfs2(int u, int l, int (&nparent)[MAX_V], vector<int> (&G)[MAX_V]) {
    if(label[u] != l) nparent[u]++;
    for(int i=0; i<G[u].size(); i++) {
        int v = G[u][i];
        if(!used[v]) {
            used[v] = true;
            dfs2(v, l, nparent, G);
        }
    }
}

int main() {
    cin >> N >> M;
    for(int m=0; m<M; m++) {
        int a, b;
        cin >> a >> b;
        G[a].push_back(b);
        rG[b].push_back(a);
    }
    
    int numc = SCC();
    
    // 統計每一個頂點父強連通分量個數 
    for(int i=1; i<=numc; i++) {
        fill(used, used+MAX_V, 0);
        int v = sccv[i];
        used[v] = true;
        dfs2(v, label[v], nparent, G);
    }
    
    // 統計每一個頂點子強連通分量個數 
    for(int i=1; i<=numc; i++) {
        fill(used, used+MAX_V, 0);
        int v = sccv[i];
        used[v] = true;
        dfs2(v, label[v], nchild, rG);
    }
    
    int cnt = 0;
    for(int n=1; n<=N; n++) {
        // 如果父強連通分量個數加子強連通分量個數加一等於總強連通分量個數 
        if(nparent[n]+nchild[n]+1==numc) cnt++;
    }
    cout << cnt;
}