传递闭包（Transitive Closure） POJ 3275

　　有时候我们需要知道有向图 G = （V, E）的顶点之间是否存在路径。 那么怎样确定有向图中每对顶点之间是否存在路径呢？ 这涉及到一个非常重要的概念—— 有向图的传递闭包。 

　　有向图G的传递闭包定义为 G' = (V, E'), 其中 E' = {(u, v) | 图 G 中存在一条从顶点 u 到顶点 v 的路径}。

　　我们可在O(n^3)（n为图G中的顶点数）的时间复杂度内计算出有向图的传递闭包。

　　Floyd-Warshall算法(每对顶点间最短路径算法， 对其做了一些改动， 来计算传递闭包)：

// G = (V, E), V = {1, 2, ..., n}

tu[i][j] = false for all possible i and j. // in fact 1 <= i, j <= n

for each edge (u, v)
    tc[u][v] = true;

for (k = 1; k <= n; k++)
     for (i = 1; i <= n; i++)
        for (j = 1; j <= n; j++) 
            tc[i][j] ||= (tc[i][k] && tc[k][j]);


// then the transitive closure of G : G' = (V, E'), where E' = {(u, v) | tc[u][v] = true}. :)

   此外，存在时间复杂度为O(nm)的算法（n = |V|, m = |E|）。 算法的伪代码如下：

// Give an O(VE)-time algorithm for computing the transitive closure of a directed
// graph G = (V, E).
 
// We compute the transitive closure as an adjacency matrix, TC[i, j]
 
// Assume that each vertex v has a unique identification number: 
// 
//               id(v) ∈ {0, 1, 2, …, |V| - 1} 
//
 
    for each vertex u 
        perform a BFS or DFS with u as the root 
        for each vertex v discovered in the search 
            TC[id(u), id(v)] = 1 
    return TC 
 
// In the extreme case, a search can traverse every edge in the dataflow graph. Hence, 
// the total time complexity of this algorithm is O(VE).

　　POJ 3275:

　　　　　　　答案： n*（n-1）/2 - |E'|, E'为输入有向图的传递闭包的边集。

　　　　　　　C++代码：

#include <stdio.h>

#define N   1001
#define M   10000

int stack[N], top = -1;
bool instack[N] = {false};

struct s_edge {
    int node, next;
} edge[M];
int adj[N];

int n, m;

bool tc[N][N] = {false};

void dfs(int u) {
    int v, i;
    for (i = adj[u]; i != -1; i = edge[i].next) {
        v = edge[i].node;
        if (!instack[v]) {
            stack[++top] = v;
            instack[v] = true;
            dfs(v);
        }
    }
}

int main() {
    int count, i, j, k;
    scanf("%d%d", &n, &m);
    for (i = 1; i <= n; i++) {
        adj[i] = -1;
    }
    for (i = 0; i < m; i++) {
        scanf("%d%d", &j, &k);
        edge[i].node = k;
        edge[i].next = adj[j];
        adj[j] = i;
    }

    // O(VE) or O(mn)
    for (count = 0, i = 1; i <= n; i++) {
         dfs(i);
         for (; top >= 0; top--) {
            j = stack[top];
            instack[j] = false;
            if (!tc[i][j]) {
                tc[i][j] = true;
                count++;
            }
         }
    }
    printf("%d
", n*(n-1)/2 - count);
    return 0;
}