POJ1236_A - Network of Schools _强连通分量::Tarjan算法

Time Limit: 1000MS

Memory Limit: 10000K

Description

A number of schools are connected to a computer network. Agreements have been developed among those schools: each school maintains a list of schools to which it distributes software (the “receiving schools”). Note that if B is in the distribution list of school A, then A does not necessarily appear in the list of school B
You are to write a program that computes the minimal number of
schools that must receive a copy of the new software in order for the
software to reach all schools in the network according to the agreement
(Subtask A). As a further task, we want to ensure that by sending the
copy of new software to an arbitrary school, this software will reach
all schools in the network. To achieve this goal we may have to extend
the lists of receivers by new members. Compute the minimal number of
extensions that have to be made so that whatever school we send the new
software to, it will reach all other schools (Subtask B). One extension
means introducing one new member into the list of receivers of one
school.

Input

The
first line contains an integer N: the number of schools in the network
(2 <= N <= 100). The schools are identified by the first N
positive integers. Each of the next N lines describes a list of
receivers. The line i+1 contains the identifiers of the receivers of
school i. Each list ends with a 0. An empty list contains a 0 alone in
the line.

Output

Your
program should write two lines to the standard output. The first line
should contain one positive integer: the solution of subtask A. The
second line should contain the solution of subtask B.

Sample Input

5
2 4 3 0
4 5 0
0
0
1 0

Sample Output

1
2

题意

有向图上有 N 个点，若干有向边。
第一问：至少给几个点传递信息，才能保证信息传遍整个图。
第二问：至少添加几条边，才能使任意选择点，都能传遍整个图。

思路

强连通分量的裸题。
强连通分量内的任意一点收到消息，内部其他各点必定都能收到消息。因此，可以把每个强连通分量缩成一个点。只需要考察入度为 0 的强连通分量的个数，就是第一问的答案。
对于第二问，是把图连接成一个强连通分量，同样可以在缩点后的图中操作。这里的做法是统计图中入度为0、出度为0的强连通分量的个数，取较大值即为第二问的答案。 本题中原图只有一个强连通分量的情况需要特判。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<vector>

 using namespace std;

 const int maxn =  + ;

 int N;
 int In[maxn], Out[maxn];

 /***************************Tarjan算法模板***************************/
 vector<int> G[maxn];
 int Mark[maxn], Root[maxn], Stack[maxn];//时间戳，根(当前分量中时间戳最小的节点)，栈
 bool Instack[maxn]; //是否在栈中标记
 int Ssc[maxn];            //每个节点所在的强连通分量的编号
 int Index, Ssc_n, Top;    //搜索时用的时间戳，强连通分量总数，栈顶指针

 void Tarjan(int u)        //u 当前搜索到的点
 {
     Mark[u] = Root[u] = ++ Index;  //每找到一个点，对时间戳和根初始化
     Stack[Top ++] = u;        //压栈
     Instack[u] = true;        //在栈中标记

     int v;

     for(int i= ; i< G[u].size(); i++)   //向下搜索
     {
         v = G[u][i];
         if(Mark[v] == )                 //没到过的点
         {
             Tarjan(v);  //先向下搜索
             if(Root[u] > Root[v]) Root[u] = Root[v];//更新根
         }
         else if(Instack[v] && Root[u] > Mark[v]) Root[u] = Mark[v];  //到过的点且点仍在栈中，试着看这个点能不能成为根
     }
 /*对当前点的搜索结束*/
     if(Mark[u] == Root[u])  //当前点本身时根
     {
         Ssc_n ++;   //更新强连通分量数

         do{    //栈中比它后入栈的元素在以它为根的强连通分量中
             v = Stack[-- Top];
             Instack[v] = false;
             Ssc[v] = Ssc_n;//把同一个强连通分支的点做上相同标记
         }while(v != u);    //直到它自己
     }
 }

 void SSC()
 {
     memset(Mark, , sizeof Mark);   //初始化时间戳和栈内标记
     memset(Instack, false, sizeof Instack);
     Index = Ssc_n = Top = ;   //初始化时间戳，强连通分量数，栈顶指针

     for(int i= ; i<= N; i++)   //保证图上所有点都访问到
         if(Mark[i] == ) Tarjan(i);
 }
 /***************************Tarjan算法模板***************************/

 int main()
 {
     //freopen("in.txt", "r", stdin);

     scanf("%d", &N);
     for(int i= ; i<= N; i++)
     {
         int x;
         while(scanf("%d", &x), x)
             G[i].push_back(x);
     }

     SSC();

     if(Ssc_n == )  //只有一个强连通分量的情况
     {
         cout << "1\n0\n";
         return ;
     }

     memset(In, , sizeof In); //求每个强连通分量的入度和出度
     memset(Out, , sizeof Out);
     for(int u= ; u<= N; u++)
     {
         for(int i= ; i< G[u].size(); i++)
         {
             int v = G[u][i];
             if(Ssc[u] != Ssc[v])//u,v两点不在同一个强连通分支
                 Out[Ssc[u]] ++, In[Ssc[v]] ++;
         }
     }

     int S1 = , S2 = ;//找入度为0、出度为0的点的数目
     for(int i= ; i<= Ssc_n; i++)
     {
         if(In[i] == ) S1 ++;
         if(Out[i] == ) S2 ++;
     }

     cout << S1 << endl << max(S1, S2) << endl;

     return ;
 }