POJ 1236 Network of Schools —— （缩点的应用）

　　题目大意：有N个学校和一些有向边将它们连结，求:

　　　　1.最少需要向几个学校发放软件，使得他们中的每一个学校最终都能够获得软件。

　　　　2.最少需要增加几条有向边使得可以从任意一个学校发放软件，使得每一个学校最终都能够获得软件。

　　分析：

　　　　1.缩点以后，找出入度为0的点的个数即可（因为没人可以给他们软件）。

　　　　2.缩点以后，答案即是max(入度为0的点，出度为0的点)。因为只要另每一对入度为0和出度为0的点相连接即可。

　　第二个问题也有无向图的版本，那样的话处理方法是：缩点以后，找出那些度为1的点，个数为cnt，向上整除2即可（即答案为（cnt+1）/2）。

　　代码如下：

#include <stdio.h>
#include <stack>
#include <algorithm>
#include <string.h>
#include <vector>
using namespace std;

const int N = 100+5;

stack<int> S;
int scc_cnt;  //强连通分量的个数
int dfs_clock;    //访问到该节点的时间戳
int belong[N];  //belong[i]表示i节点所属于第几个强连通分量
int dfn[N];     //表示第i个节点被访问的时间
int low[N];    //表示第i个节点的子节点所能访问到的最小的dfn值
vector<int> G[N];
int in[100+5],out[100+5];

void dfs(int u)
{
    dfn[u] = low[u] = ++dfs_clock;
    S.push(u);
    for(int i=0;i<G[u].size();i++)
    {
        int v = G[u][i];
        if(!dfn[v])
        {
            dfs(v);
            low[u] = min(low[u],low[v]);
        }
        else if(!belong[v])
        {
            low[u] = min(low[u],low[v]);
        }
    }
    if(low[u]==dfn[u])
    {
        scc_cnt++;
        for(;;)
        {
            int x = S.top();S.pop();
            belong[x] = scc_cnt;
            if(x==u) break;
        }
    }
}

void scc(int n)
{
    memset(dfn,0,sizeof(dfn));
    memset(belong,0,sizeof(belong));
    dfs_clock = scc_cnt = 0;
    for(int i=1;i<=n;i++)
    {
        if(!dfn[i]) dfs(i);
    }
}

int main()
{
    int n;
    while(scanf("%d",&n)==1)
    {
        memset(in,0,sizeof(in));
        memset(out,0,sizeof(out));
        for(int i=1;i<=n;i++) G[i].clear();
        for(int i=1;i<=n;i++)
        {
            int to;
            while(scanf("%d",&to)==1&&to)
            {
                G[i].push_back(to);
            }
        }
        
        scc(n);
        if(scc_cnt==1)
        {
            puts("1
0");
            continue;
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=0;j<G[i].size();j++)
            {
                int v = G[i][j];
                if(belong[i]==belong[v]) continue;
                in[belong[v]]++;
                out[belong[i]]++;
            }
        }
        int incnt=0,outcnt=0;
        for(int i=1;i<=scc_cnt;i++)
        {
            if(!in[i]) incnt++;
            if(!out[i]) outcnt++;
        }
        printf("%d
%d
",incnt,max(incnt,outcnt));
    }
    return 0;
}