PKU 1236 Network of Schools - 最小点基

题目大意：

N个高校之间有一些单向的网络链接（N<100），当发布一个软件时，学校i收到软件时，它可以将软件发送给所有它链接到的学校。现在要求发布一款软件，最少需要发给多少个学校，使得所有学校都可以收到软件（问题A）。最少需要添加多少条单向网络链接，可以使得将软件任意发给一个学校，使得所有学校都可以收到（问题B）。

分析：

我们先来讨论问题A。这个问题在吴文虎的OI图论书上有介绍过，叫做有向图的最小点基。

首先，求出有向图的极大强连通分量，在同一个强连通分量里的学校任意一个收到软件，整个强连通分量里的学校都可以收到。将每个强连通分量缩成一个点，构成一个新的有向无环图。当强连通分量i收到软件，那么i可达的强连通分量都可以收到软件。

我们称入度为0的强连通分量为最高强连通分量。显然，每个最高强连通分量都必须单独发送一次软件，而其他强连通分量都可以通过最高强连通分量到达。所以，最高强连通分量的个数也就是问题A的解。

至于问题B，我猜测是MAX(入度为0的点的个数,出度为0的点的个数)，没想到居然对了，也没仔细证明。注意的是，当原图只有一个强连通分量是，问题B的答案是0。

 

1. /*
2. PKU1236 Network of Schools
3. */
5. #include <stdio.h>
6. #include <stdlib.h>
7. #include <memory.h>
9. #define clr(a) memset(a,0,sizeof(a))
10. #define MAX(a,b) ((a)>(b)?(a):(b))
12. #define N 105
13. #define M 10005
15. typedef struct NodeStr{
16.     int j;
17.     struct NodeStr *next;
18. }Node;
20. Node mem[M*2];
21. int memp;
23. void addEdge(Node *e[],int i,int j){
24.     Node *p = &mem[memp++];
25.     p->next = e[i]; p->j = j; e[i] = p;
26. }
28. int g_DFS_First;
30. void DFS_conn(Node* e[],int i,int mark[],int f[],int* nf){
31.     int j; Node* p;
32.     if(mark[i]) return; else mark[i]=1;
33.     if(!g_DFS_First) f[i]=*nf;  //反向搜索，获取连通分量编号
34.     for(p=e[i];p!=NULL;p=p->next) DFS_conn(e,p->j,mark,f,nf);
35.     if(g_DFS_First) f[(*nf)++]=i;   //正向搜索，获取时间戳
36. }
38. int Connection(Node* e[],int n,int con[]){
39.     int i,j,k,mark[N],ncon,time[N],ntime;//time[i]表示时间戳为i的节点
40.     Node *p,*re[N]; //反向边
41.     clr(re);        //构造反向边邻接表
42.     for(i=0;i<n;i++) for(p=e[i];p!=NULL;p=p->next) addEdge(re,p->j,i);
44.     g_DFS_First = 1;    //正向DFS，获得时间戳 
45.     clr(mark); clr(time); ntime=0;
46.     for(i=0;i<n;i++) if(!mark[i]) DFS_conn(e,i,mark,time,&ntime);
47.     
48.     g_DFS_First = 0;    //反向DFS，获得强连通分量
49.     clr(mark); clr(con); ncon=0;
50.     for(i=n-1;i>=0;i--) if(!mark[time[i]])
51.     { DFS_conn(re,time[i],mark,con,&ncon); ncon++; }
52.     
53.     return ncon;
54. }
56. /*
57. 收缩强连通分量
58. 参数:
59.     e[]有向图邻接表.返回强连通分量个数m.
60.     ce[]返回收缩强连通分量后的有向图邻接表[0,m-1],
61.     con[]返回顶点i所属强连通分量的编号con[i]
62. */
63. int ShrinkConnection(Node *e[],int n,Node *ce[],int con[]){
64.     int i,j,k,m; Node *p,*q;
65.     m=Connection(e,n,con);
66.     for(i=0;i<m;i++) ce[i]=NULL;
67.     
68.     for(k=0;k<n;k++){
69.         for(i=con[k],p=e[k];p!=NULL;p=p->next){
70.             for(j=con[p->j],q=ce[i];q!=NULL;q=q->next)
71.                 if(q->j == j) break;
72.             if(q==NULL&&i!=j) addEdge(ce,i,j);
73.         }
74.     }
75.     return m;
76. }
78. /*****************************************/
80. int main()
81. {
82.     int i,j,k;
83.     int n,m,con[N],dout[N],din[N];
84.     Node *e[N],*ce[N],*p;
85.     int ansA,ansB;
86.     
87.     while(scanf("%d",&n)!=EOF){
88.         //init
89.         memp=0;
90.         clr(e);
91.         //input
92.         for(i=0;i<n;i++){
93.             while(scanf("%d",&j),j)
94.                 addEdge(e,i,j-1);
95.         }
96.         //ShrinkConnection
97.         m=ShrinkConnection(e,n,ce,con);
98.         //work d[] - ce
99.         clr(din); clr(dout);
100.         for(i=0;i<m;i++){
101.             for(p=ce[i];p!=NULL;p=p->next)
102.                 din[p->j]++,dout[i]++;
103.         }
104.         
105.         //get ans
106.         ansA=ansB=0;
107.         for(i=0;i<m;i++){
108.             if(din[i]==0) ansA++;
109.             if(dout[i]==0) ansB++;
110.         }
111.         ansB = MAX(ansA,ansB);
112.         if(m==1) ansB=0;
113.         
114.         printf("%d/n%d/n",ansA,ansB);
115.         
116.     }
117.     
118.     return 0;
119. }