poj~1236 Network of Schools 强连通入门题

一些学校连接到计算机网络。这些学校之间已经达成了协议：

每所学校都有一份分发软件的学校名单（“接收学校”）。

请注意，如果B在学校A的分发名单中，则A不一定出现在学校B的名单中
您需要编写一个计划，计算必须接收新软件副本的最少学校数量，

以便软件根据协议（子任务A）到达网络中的所有学校。作为进一步的任务，

我们希望确保通过将新软件的副本发送到任意学校，该软件将覆盖网络中的所有学校。

为了实现这一目标，我们可能需要扩大新成员的接收者名单。

计算必须做的扩展的最小数目，以便我们发送新软件的任何学校，

它将到达所有其他学校（Subtask B）。

一种扩展意味着将一名新成员引入一所学校的接收者名单。

这题强连通水题 ，模板题目，

第一问求出最少要几个点才能到任意点

其实就是一个强连通缩点后，求出有几个入度为0的点，

第二问求出要加上几条边把所点后的有向无环图变成一个强连通图

就是求 max(sumin, sumout)

 #include <cstdio>
 #include <cstring>
 #include <string>
 #include <algorithm>
 #include <queue>
 using namespace std;

 const int maxn = 1e5 + ;
 int n, m, u, v, tot, top, cnt, flag;
 struct node {
     int v, next;
 } edge[maxn];
 int head[maxn], instack[maxn], s[maxn];
 int dfn[maxn], low[maxn], belong[maxn];
 void init() {
     tot = cnt = top = flag = ;
     memset(s, , sizeof(s));
     memset(head, -, sizeof(head));
     memset(dfn, , sizeof(dfn));
     memset(instack, , sizeof(instack));
 }
 void add(int u, int v) {
     edge[tot].v = v;
     edge[tot].next = head[u];
     head[u] = tot++;
 }
 void tarjin(int v) {
     dfn[v] = low[v] = ++flag;
     instack[v] = ;
     s[top++] = v;
     for (int i = head[v] ; i != - ; i = edge[i].next) {
         int j = edge[i].v;
         if (!dfn[j]) {
             tarjin(j);
             low[v] = min(low[v], low[j]);
         } else if (instack[j]) low[v] = min(low[v], dfn[j]);
     }
     if (dfn[v] == low[v]) {
         cnt++;
         int t;
         do {
             t = s[--top];
             instack[t] = ;
             belong[t] = cnt;
         } while(t != v) ;
     }
 }
 void solve() {
     for (int i =  ; i <= n ; i++)
         if (!dfn[i]) tarjin(i);
 }
 int in[maxn], out[maxn];
 int main() {
     while(scanf("%d", &n) != EOF) {
         init();
         memset(in, , sizeof(in));
         memset(out, , sizeof(out)) ;
         for (int i =  ; i <= n ; i++) {
             int v;
             scanf("%d", &v);
             while(v) {
                 add(i, v);
                 scanf("%d", &v);
             }
         }
         for (int i =   ; i <= n ; i++)
             if (!dfn[i]) tarjin(i);
         for (int i =  ; i <= n ; i++) {
             for (int j = head[i] ; ~j ; j = edge[j].next) {
                 if (belong[edge[j].v] != belong[i]) {
                     in[belong[edge[j].v]]++;
                     out[belong[i]]++;
                 }
             }
         }
         int sumin = , sumout = ;
         for (int i =  ; i <= cnt ; i++) {
             if (!in[i]) sumin++;
             if (!out[i])sumout++;
         }
         printf("%d\n", sumin);
         if (cnt == ) printf("0\n");
         else printf("%d\n", max(sumin, sumout));
     }
     return ;
 }