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 = +;

 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[+],out[+];

 void dfs(int u)
 {
     dfn[u] = low[u] = ++dfs_clock;
     S.push(u);
     for(int i=;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,,sizeof(dfn));
     memset(belong,,sizeof(belong));
     dfs_clock = scc_cnt = ;
     for(int i=;i<=n;i++)
     {
         if(!dfn[i]) dfs(i);
     }
 }

 int main()
 {
     int n;
     while(scanf("%d",&n)==)
     {
         memset(in,,sizeof(in));
         memset(out,,sizeof(out));
         for(int i=;i<=n;i++) G[i].clear();
         for(int i=;i<=n;i++)
         {
             int to;
             while(scanf("%d",&to)==&&to)
             {
                 G[i].push_back(to);
             }
         }

         scc(n);
         if(scc_cnt==)
         {
             puts("1\n0");
             continue;
         }
         for(int i=;i<=n;i++)
         {
             for(int j=;j<G[i].size();j++)
             {
                 int v = G[i][j];
                 if(belong[i]==belong[v]) continue;
                 in[belong[v]]++;
                 out[belong[i]]++;
             }
         }
         int incnt=,outcnt=;
         for(int i=;i<=scc_cnt;i++)
         {
             if(!in[i]) incnt++;
             if(!out[i]) outcnt++;
         }
         printf("%d\n%d\n",incnt,max(incnt,outcnt));
     }
     return ;
 }