POJ1236 强连通分支（strongly connected component _kosaraju algorithm)

题目的意思是：总学校分发软件，每个学校得过软件后，可以通过单向网络分发软件，求（1）最少的软件分发数;(2)添加最少的线路，使发放到任意的学校就可以让所有学校收到。

思路：

（1）有kosaraju algorithm求出各连通分支，然后通过深搜转置的图计算出深度优先树；

（2）在深度优先树中求出出度为0的结点的个数即为第一问的解。因为所有入度不为0的结点可以由入度为0的点出发到达。

（3）求深度优先树的的出度为0的结点与入度为0的点的最大值。

        1、弱连通图没有出度为0或入度为0的点必为强连通图

       

       

Network of Schools

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 4373		Accepted: 1710

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



#include <iostream>
#include <cstdio>
#include <cstring>
const int MAXN=101;
bool con[MAXN][MAXN];
bool transpose[MAXN][MAXN];
int classify;
int finish[MAXN];
bool visit[MAXN];
int sub;
int distribute[MAXN];
int treenode[MAXN][MAXN];
int n;
void dfs(int u)
{
  int i;
  for(i=1;i<=n;i++)
    {
      if(con[u][i]==true&&visit[i]==false)
	{
	  visit[i]=true;
	  dfs(i);
	  
	  //sub++;	
	  //finish[sub]=i;
	}
    }
  sub++;
  finish[sub]=u;
  
}
void trandfs(int u)
{
  int i;
  for(i=sub;i>=1;i--)
    {
      if(transpose[u][finish[i]]==1&&visit[finish[i]]==false)
	{ 
	  distribute[finish[i]]=classify;
	  visit[finish[i]]=true;
	  trandfs(finish[i]);
	}
    }
}
int main()
{
   int to;
   int i;
   int j;
  while(scanf("%d",&n)!=EOF)
    {
      memset(con,0,sizeof(con));
      memset(transpose,0,sizeof(transpose));
      for(i=1;i<=n;i++)
	{
	 
	  while(scanf("%d",&to),to)
	    {
	      con[i][to]=1;
	      transpose[to][i]=1;
	    }
	}
      memset(visit,0,sizeof(visit));
      sub=0;
      for(i=1;i<=n;i++)
	{
	  if(visit[i]==false)
	    {
	      visit[i]=true;
	      dfs(i);
	      //    sub++;
	      //finish[sub]=i;
	    }
	}//DFS teh graph and compute finish time finish[u]  for each vertex u
      memset(visit,0,sizeof(visit));
      classify=0;
      for(i=sub;i>=1;i--)
	{
	  if(visit[finish[i]]==false)
	    {
	      classify++;
	      distribute[finish[i]]=classify;
	      
	      visit[finish[i]]=true;

	      trandfs(finish[i]);
	    }
	}//DFS the transpose graph follow the decrease finish time
      memset(treenode,0,sizeof(treenode));
      for(i=1;i<=n;i++)
	{
	  for(j=1;j<=n;j++)
	    {
	      if(con[i][j]==1)
		{
		  if(distribute[i]!=distribute[j])
		    {
		      treenode[distribute[i]][distribute[j]]=1;
		    }
		}
	    }
	}//construct the depth-first tree as the separate strongly connected componet
      int zeroindegree=0;
      for(i=1;i<=classify;i++)
	{
	  zeroindegree++;
	  for(j=1;j<=classify;j++)
	    {
	      if(treenode[j][i]==1)
		{
		  zeroindegree--;
		  break;
		}
	      
	    }
	      
	 
	}//compute the vertex which indegree is zero
      int zerooutdegree=0;
      for(i=1;i<=classify;i++)
	{
	  zerooutdegree++;
	  for(j=1;j<=classify;j++)
	    {
	      if(treenode[i][j]==1)
		{
		  zerooutdegree--;
		  break;
		}
	    }
	  
	}//compute the vertex which outdegree is zero
      printf("%d/n",zeroindegree);
      if(classify==1)
	{
	  printf("0/n");
	}
      else
	{
	  if(zerooutdegree>zeroindegree)
	    {
	      printf("%d/n",zerooutdegree);
	    }
	  else
	    {
	      printf("%d/n",zeroindegree);
	    }
	}





	  

      
      
      
    }
  return 0;
}