HDU 2767（ Proving Equivalences ）强连通模板（tarjan 模板）简易

该文主要是写一下强连通题目的一种方法tarjan的模板，这是一种判断连通分支的一种方法，能够准确的找出图的强连通分支，并且，将其编号。
下面的是一个HDU中的一个模板题：
Proving Equivalences
Consider the following exercise, found in a generic linear algebra textbook.

Let A be an n × n matrix. Prove that the following statements are equivalent:

1. A is invertible.
2. Ax = b has exactly one solution for every n × 1 matrix b.
3. Ax = b is consistent for every n × 1 matrix b.
4. Ax = 0 has only the trivial solution x = 0.

The typical way to solve such an exercise is to show a series of implications. For instance, one can proceed by showing that (a) implies (b), that (b) implies (c), that (c) implies (d), and finally that (d) implies (a). These four implications show that the four statements are equivalent.

Another way would be to show that (a) is equivalent to (b) (by proving that (a) implies (b) and that (b) implies (a)), that (b) is equivalent to (c), and that (c) is equivalent to (d). However, this way requires proving six implications, which is clearly a lot more work than just proving four implications!

I have been given some similar tasks, and have already started proving some implications. Now I wonder, how many more implications do I have to prove? Can you help me determine this?
Input
On the first line one positive number: the number of testcases, at most 100. After that per testcase:

• One line containing two integers n (1 ≤ n ≤ 20000) and m (0 ≤ m ≤ 50000): the number of statements and the number of implications that have already been proved.

• m lines with two integers s1 and s2 (1 ≤ s1, s2 ≤ n and s1 ≠ s2) each, indicating that it has been proved that statement s1 implies statement s2.
  Output
  Per testcase:

• One line with the minimum number of additional implications that need to be proved in order to prove that all statements are equivalent.
  Sample Input
  2
  4 0
  3 2
  1 2
  1 3
  Sample Output
  4
  2
  这个题目的题意：
  题目给我出的是一个单向图，并且给出单向图的点数和已知的边的数目，并且给出边的信息，让你写出最小加入几条边，任意两点都相互连通（强连通图）
  题解：
  我们可以通过tarjan方法找出连通分支（缩点），然后把缩点后的图重新计算出入度，入度为0，表示没有边进入，出度为0表示没有边出，每次加一条边减少一个入读，一个出度，所以结果为他们两个的最大值。
  代码：

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <queue>
#include <vector>
#include <cstring>
using namespace std;
typedef long long ll;
const int maxn = 20005;
typedef vector<int> vec;

int Stack[maxn],inStack[maxn],innum[maxn],outnum[maxn];
vec edge[maxn];
int dfn[maxn],low[maxn],belong[maxn];
int scc;
int n,m;
int ink,outk;
int top,index;

void tarjan(int u){
    inStack[u] = 1;
    dfn[u] = low[u] = ++index;
    Stack[top++] = u;
    int len = edge[u].size();
    int v;
    for(int i=0;i<len;i++){
        v = edge[u][i];
        if(!dfn[v]){
            tarjan(v);
            low[u] = min(low[u],low[v]);
        }
        else if(inStack[v]){
            low[u] = min(low[u],low[v]);
        }
    }
    if(dfn[u] == low[u]){
        scc++;
        do{
            v = Stack[--top];
            inStack[v] = 0;
            belong[v] = scc;
        }while(u!=v);
    }
}

void slove(){
    memset(dfn,0,sizeof(dfn));
    memset(inStack,0,sizeof(inStack));
    index = scc = top = 0;
    for(int i=1;i<=n;i++){
        if(!dfn[i]){
            tarjan(i);
        }
    }
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&m);
        int tmp1,tmp2;
        for(int i=0;i<=n+1;i++)
            edge[i].clear();
        for(int i=0;i<m;i++){
            scanf("%d%d",&tmp1,&tmp2);
            edge[tmp1].push_back(tmp2);
        }
        slove();
        if(scc == 1){
            printf("0\n");
            continue;
        }
        memset(innum,0,sizeof(innum));
        memset(outnum,0,sizeof(outnum));
        for(int i=1;i<=n;i++){
            for(int j=0;j<edge[i].size();j++){
                if(belong[i]==belong[edge[i][j]])
                    continue;
                innum[belong[edge[i][j]]] = 1;
                outnum[belong[i]] = 1;
            }
        }
        ink = outk = 0;
        for(int i=1;i<=scc;i++){
            if(!innum[i])
                ink++;
            if(!outnum[i])
                outk++;
        }
        printf("%d\n",max(ink,outk));
    }
    return 0;
}