POJ1236(KB9-A 强连通分量)

Network of Schools

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 19326		Accepted: 7598

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

Source

IOI 1996

 

题意：问题1：对于有向图，问选多少个点出发，可以走遍所有点。

　　　问题2：对于有向图，问最少加几条边，使得图强连通

 

思路：问题1：强连通分量缩点后得到DAG，入度为0的连通分量的数量即为答案。

　　　问题2：强连通分量缩点后得到DAG，出度为0的连通分量连向入度为0的连通分量，答案为max（出度为0的连通分量数，入度为0的连通分量数）

　　　　　　  但是当只有一个强连通分量的时候，答案为0。

 

 //2017-08-20
 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <cmath>
 #include <vector>

 using namespace std;

 const int N = ;
 int n, in_degree[N], out_degree[N];
 bool vis[N];
 vector<int> G[N];
 vector<int> rG[N];
 vector<int> vs;
 int cmp[N];

 void add_edge(int u, int v){
     G[u].push_back(v);
     rG[v].push_back(u);
 }

 //input: u 顶点
 //output: vs 后序遍历顺序的顶点列表
 void dfs(int u){
     vis[u] = true;
     for(int i = ; i < G[u].size(); i++){
         int v = G[u][i];
         if(!vis[v])
           dfs(v);
     }
     vs.push_back(u);

 }

 //input: u 顶点编号; k 拓扑序号
 //output: cmp[] 强连通分量拓扑序
 void rdfs(int u, int k){
     vis[u] = true;
     cmp[u] = k;
     for(int i = ; i < rG[u].size(); i++){
         int v = rG[u][i];
         if(!vis[v])
           rdfs(v, k);

     }

 }

 //Strongly Connected Component 强连通分量
 //input: n 顶点个数
 //output: k 强连通分量数;
 int scc(){
     memset(vis, , sizeof(vis));
     vs.clear();
     for(int u = ; u <= n; u++)
       if(!vis[u]){
           dfs(u);
       }
     int k = ;
     memset(vis, , sizeof(vis));
     for(int i = vs.size()-; i >= ; i--)
       if(!vis[vs[i]])
         rdfs(vs[i], k++);
     return k;
 }

 void solve(){
     int k = scc();
     int ans = ;
     memset(in_degree, , sizeof(in_degree));
     memset(out_degree, , sizeof(out_degree));
     for(int u = ; u <= n; u++){
         memset(vis, , sizeof(vis));
         for(int i = ; i < G[u].size(); i++){
             int v = G[u][i];
             if(vis[v])continue;
             vis[v] = ;
             if(cmp[u] != cmp[v]){
                 out_degree[cmp[u]]++;
                 in_degree[cmp[v]]++;
             }
         }
     }
     int a = , b = ;
     for(int i = ; i < k; i++){
           if(in_degree[i] == )a++;
         if(out_degree[i] == )b++;
     }
     ans = max(a, b);
     if(k == )ans = ;
     printf("%d\n%d\n", a, ans);
 }

 int main()
 {
     while(scanf("%d", &n)!=EOF){
         for(int u = ; u <= n; u++){
             G[u].clear();
             rG[u].clear();
         }
         int v;
         for(int u =; u <= n; u++){
             while(scanf("%d", &v)== && v){
                 add_edge(u, v);
             }
         }
         solve();
     }

     return ;
 }