POJ 1236 Network of Schools

 题目大意：

给定一个有向图，求：
1) 至少要选几个顶点，才能做到从这些顶点出
   发，可以到达全部顶点
2) 至少要加多少条边，才能使得从任何一个顶
　点出发，都能到达全部顶点
   顶点数<= 100

有用的定理：

有向无环图中所有入度不为0的点，一定可以由某个入度为0的点出发可达。由于无环，所以从任何入度不为0的点往回走必然终止于一个入度为0的点

解题思路：

1. 求出所有强连通分量

2. 每个强连通分量缩成一点，则形成一个有向无环图DAG。

3. DAG上面有多少个入度为0的顶点，问题1的答案就是多少

在DAG上要加几条边，才能使得DAG变成强连通的，问题2的答案就是多少

 加边的方法：要为每个入度为0的点添加入边，为每个出度为0的点添加出边假定有 n 个入度为0的点，m个出度为0的点，max(m,n)就是第二个问题的解(证明难，略）

 

当我们求出强联通分量之后就可以，然后重新构图， 最后得出结果， 有一个答案要特殊判断一下， 因为只有一个强联通分量的时候是不需要多加边，因此要特殊判断一下。

 

 

 

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
#include <cmath>
#include <stack>
#include <cstring>
using namespace std;
#define INF 0xfffffff
#define maxn 106
#define min(a,b) (a<b?a:b)
#define max(a,b) (a>b?a:b)
stack<int> S;
bool inStack[maxn];
int low[maxn],dfn[maxn], n, time, belong[maxn], cnt;
bool G[maxn][maxn];

void init()
{
    memset(inStack, false, sizeof(inStack));
    memset(low, 0, sizeof(low));
    memset(dfn, 0, sizeof(dfn));
    memset(G, false, sizeof(G));
    memset(belong, 0, sizeof(belong) );
    cnt = time = 1;
}
void tarjan(int u)
{
    low[u] = dfn[u] = time ++;
    S.push(u);
    inStack[u] = true;
    int i, v;
    for(i=1; i<=n; i++)
    {
        if(!G[u][i])
            continue;
        
        if( !low[i])
        {
            tarjan(i);
            low[u] = min(low[u], low[i]);
        }
        else if( inStack[i] )
        {
            low[u] = min(low[u], dfn[i]);
        }
    }
    
    if(low[u] == dfn[u])
    {
        do
        {
            v = S.top();
            S.pop();
            inStack[v] = false;
            belong[v] = cnt;
        }
        while(u != v);
        cnt ++;
    }
}
void solve()
{
    int in[maxn] = {0}, out[maxn] = {0}, a, b;
    bool maps[maxn][maxn] = {0};
    int i, j;
    for(i=1; i<=n; i++)
    {
        if(!low[i])
            tarjan(i);
    }
    
    for(i=1; i<=n; i++)
    {
        for(j=1; j<=n; j++)
        {
            if(G[i ][j ] && belong[i] != belong[j])
            {
                maps[belong[i] ][belong[j] ] = true;
            }
        }
    }
    a = b = 0;
    for(i=1; i<cnt; i++)
    {
        for(j=1; j<cnt; j++)
        {
            if(maps[i][j])
            {
                in[j] ++;
                out[i] ++;
            }
        }
    }
    
    for(i=1; i<cnt; i++)
    {
        if(in[i] == 0)
            a ++;
        if(out[i] == 0)
            b ++;
    }
    printf("%d\n", a);
    
    if(cnt == 2)
        printf("0\n");
    else
        printf("%d\n", max(a,b) );
    
}

int main()
{
    int i, a;
    while(scanf("%d",&n) != EOF)
    {
        init();
        for(i=1; i<=n; i++)
        {
            while(scanf("%d",&a), a)
            {
                G[i][a] = true;
            }
        }
        
        solve();
    }
    return 0;
}