hdu2767 Proving Equivalences

Problem Description 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.

问题可以转化成，在一个有向图里最少添加几条边可以使原图强连通。
首先tarjan求scc缩点，然后在得到的dag上考虑。
需要连边的是那些入度为零或者出度为零的点。显然在他们之间【入度为零和出度为零的点之间】互相连边最节省。所以答案就是max(入度为零的点的个数，出度为零的点的个数)。

#include<cstdio>
#include<cstring>
#include<vector>
#include<stack>
using namespace std;
#define M(a) memset(a,0,sizeof(a))
vector<int> to[20010];
stack<int> sta;
int dfn[20010],low[20010],num[20010],tot,m,n,clo,in[20010],out[20010];
bool ins[20010];
void init()
{
    int i,x,y;
    clo=tot=0;
    while (!sta.empty()) sta.pop();
    scanf("%d%d",&n,&m);
    for (i=1;i<=n;i++)
      dfn[i]=low[i]=num[i]=ins[i]=in[i]=out[i]=0;
    for (i=1;i<=n;i++)
      to[i].clear();
    for (i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);
        to[x].push_back(y);
    }
}
void dfs(int u)
{
    int i,j,k,x,y,v;
    dfn[u]=low[u]=++clo;
    sta.push(u);
    ins[u]=1;
    for (i=0;i<to[u].size();i++)
    {
        v=to[u][i];
        if (!dfn[v])
        {
            dfs(v);
            low[u]=min(low[u],low[v]);
        }
        else if (ins[v])
          low[u]=min(low[u],dfn[v]);
    }
    if (low[u]==dfn[u])
    {
        tot++;
        while (1)
        {
            x=sta.top();
            sta.pop();
            ins[x]=0;
            num[x]=tot;
            if (x==u) break;
        }
    }
}
void find()
{
    for (int i=1;i<=n;i++)
      if (!dfn[i]) dfs(i);
}
int solve()
{
    int i,j,k,x,y,z,cnt_in=0,cnt_out=0;
    if (tot==1)
      return 0;
    for (i=1;i<=n;i++)
      for (j=0;j<to[i].size();j++)
        if (num[i]!=num[to[i][j]])
        {
            out[num[i]]++;
            in[num[to[i][j]]]++;
        }
    for (i=1;i<=tot;i++)
    {
        if (!in[i]) cnt_in++;
        if (!out[i]) cnt_out++;
    }
    return max(cnt_in,cnt_out);
}
int main()
{
    int T;
    scanf("%d",&T);
    while (T--)
    {
        init();
        find();
        printf("%d\n",solve());
    }
}