（连通图 模板题 出度和入度）Network of Schools--POJ--1236

链接：

http://poj.org/problem?id=1236

http://acm.hust.edu.cn/vjudge/contest/view.action?cid=82833#problem/A

题意：学校有一些单向网络，现在需要传一些文件

求：1，求最少需要向几个学校分发文件才能让每个学校都收到，

　　2，需要添加几条网络才能从任意一个学校分发都可以传遍所有学校。

解题思路（参考大神的）：

—        1. 求出所有强连通分量

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

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

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

加边的方法：

要为每个入度为0的点添加入边，为每个出度为0的点添加出边

假定有 n 个入度为0的点，m个出度为0的点，如何加边？

把所有入度为0的点编号 0,1,2,3,4 ....N -1

每次为一个编号为i的入度0点可达的出度0点，添加一条出边，连到编号为(i+1)%N 的那个出度0点,

这需要加n条边

若 m <= n，则

加了这n条边后，已经没有入度0点，则问题解决，一共加了n条边

若 m > n，则还有m-n个入度0点，则从这些点以外任取一点，和这些点都连上边，即可，这还需加m-n条边。

所以，max(m,n)就是第二个问题的解

此外：当只有一个强连通分支的时候，就是缩点后只有一个点，虽然入度出度为0的都有一个，但是实际上不需要增加清单的项了，所以答案是1，0；

代码：

 #include<cstdio>
 #include<cstdlib>
 #include<cmath>
 #include<iostream>
 #include<algorithm>
 #include<cstring>
 #include<vector>
 using namespace std;
 #define N 105

 struct Edge{int v, next;}e[N*N];

 int n, Time, bnt, cnt, top;
 int low[N], dfn[N], Head[N], sta[N], InStack[N], belong[N];

 void Init()
 {
     Time = bnt = cnt = top = ;
     memset(low, , sizeof(low));
     memset(dfn, , sizeof(dfn));
     memset(Head, -, sizeof(Head));
 }
 void Add(int u, int v)
 {
     e[cnt].v = v;
     e[cnt].next = Head[u];
     Head[u] = cnt++;
 }

 void Tarjan(int u)
 {
     int j;
     low[u] = dfn[u] = ++Time;
     InStack[u] = ;
     sta[++top]=u;

     for(j=Head[u]; j!=-; j=e[j].next)
     {
         int v = e[j].v;

         if(!dfn[v])
         {
             Tarjan(v);
             low[u] = min(low[u], low[v]);
         }
         else if(InStack[v])
             low[u] = min(low[u], dfn[v]);
     }

     if(dfn[u] == low[u])
     {
         ++bnt;
         do
         {
             j = sta[top--];
             InStack[j] = false;
             belong[j] = bnt;
         }while(u!=j);
     }
 }

 int main()
 {
     while(scanf("%d", &n)!=EOF)
     {
         int u, v, i, j;

         Init();

         for(i=; i<=n; i++)
         {
             while(scanf("%d", &v), v)
                 Add(i, v);
         }

         for(i=; i<=n; i++)
             if(!dfn[i])
             Tarjan(i);

         int r[N]={}, c[N]={}, rn=, cn=;

         for(i=; i<=n; i++)
         for(j=Head[i]; j!=-; j=e[j].next)
         {
             u = belong[i], v = belong[e[j].v];
             if(u!=v)
             {
                 c[u]++;
                 r[v]++;
             }
         }

         for(i=; i<=bnt; i++)
         {
             if(r[i]==) rn++;
             if(c[i]==) cn++;
         }

         if(bnt == )
             printf("1\n0\n");
         else
             printf("%d\n%d\n", rn, max(rn, cn));

     }
     return ;
 }