PKU 2942 Knights of the Round Table - 无向图的块 判断奇圈

题目大意:

N个骑士某些骑士之间会有仇恨。骑士们开会时围坐在一个圆桌旁。一次会议能够举行，当且仅当没有相邻的两个骑士相互仇恨，且开会人数为大于2的奇数。若某个骑士任何会议都不能参加，那么就必须将它踢出。给出骑士之间的仇恨关系，问需要踢出多少个骑士。

分析：

首先，求出无向图的块（即同一个块中没有割点）。块中的节点一定是可以组成环的。

可以证明，若块中存在一个奇圈，那么块中所有顶点都在一个奇圈上。

那么，对于每个块进行判定，若该块存在奇圈，则块中所有的骑士都不会被踢出。即可求解。

需要注意的是，同一个顶点可能出现在多个块当中。所以在计数时不能直接累加含有奇圈的块的顶点，而是要先标记再累加。

至于只有一个骑士的情况怎么处理，貌似题目没有这样的数据……

 

1. /*
2. PKU2942 Knights of the Round Table
3. */
5. #include <stdio.h>
6. #include <memory.h>
8. #define clr(a) memset(a,0,sizeof(a))
9. #define MIN(a,b) ((a)>(b)?(b):(a))
11. #define N 1005
12. #define M 4000005
14. typedef struct NS{ int j; struct NS *next; }Node;
15. Node mem[M]; int memp;
16. void addEdge(Node *e[],int i,int j){
17.     Node *p=&mem[memp++]; p->j=j; p->next=e[i]; e[i]=p;
18. }
20. int anc[N],mark[N],deep[N],stack[N],sp,nblock;  //anc[] DFS中i可达最远祖先的深度
23. int DFS_block(Node *e[],int i,int father,int dth,int cut[],Node *be[]){
24.     int j,k,tofather=0,sons=0; Node *p;
25.     stack[sp++]=i; mark[i]=1; anc[i]=deep[i]=dth;
26.     
27.     for(p=e[i];p!=NULL;p=p->next){
28.         j=p->j;
29.         if(mark[j]==1 && (j!=father||tofather)) anc[i]=MIN(anc[i],deep[j]);
30.         if(mark[j]==0){
31.             DFS_block(e,j,i,dth+1,cut,be);
32.             anc[i]=MIN(anc[i],anc[j]); sons++;
33.             if((father==-1&&sons>1)||(father!=-1&&anc[j]>=deep[i]))
34.                 cut[i]=1;
35.             if(anc[j]>=deep[i]) {
36.                 addEdge(be,nblock,i);
37.                 for(stack[sp]=-1;stack[sp]!=j;addEdge(be,nblock,stack[--sp]));
38.                 nblock++;
39.             }
40.         }
41.         if(j==father) tofather=1;
42.     }
43.     mark[i]=2;
44. }
46. /*
47. 无向图的块
48. 参数:
49.     传入无向图邻接表e[], 返回无向图块的个数nblock
50.     cut[]返回顶点i是否为割顶
51.     be[]返回每个块所包含的顶点,be[k]之后是块k包含的所有顶点.
52. */
53. int Block(Node *e[],int n,int cut[],Node *be[]){
54.     int i,j,k,f[N]; 
55.     clr(mark); nblock=0; sp=0;
56.     for(i=0;i<n;i++) if(mark[i]==0) DFS_block(e,i,-1,1,cut,be);
57.     return nblock;
58. }
60. /**************************************/
63. int DFS_judge(Node *e[],int i,int col,int in[],int color[]){
64.     int j,k; Node *p;
65.     color[i]=col;
66.     for(p=e[i];p!=NULL;p=p->next){
67.         j=p->j;
68.         if(!in[j]) continue;
69.         if(!color[j]){ if(DFS_judge(e,j,-col,in,color)) return 1;}
70.         else {
71.             if(color[j]==col) {
72.                 return 1;
73.             }
74.         }
75.     }
76.     return 0;
77. }
79. void Judge(Node *e[],Node *block,int good[]){
80.     int i,j,k; Node *p,*q;
81.     int in[N],color[N];
82.     clr(in); clr(color);
83.     for(p=block;p!=NULL;p=p->next){
84.         in[p->j]=1;
85.     }
86.     if(DFS_judge(e,block->j,1,in,color)){
87.         for(p=block;p!=NULL;p=p->next) good[p->j]=1;
88.     }
89. }
92. int n,m,w;
93. Node *e[N];
94. Node *be[N];
95. int cut[N];
96. int good[N],count;
97. int hate[N][N];
99. int main()
100. {
101.     int i,j,k;
102.     
103.     while(scanf("%d%d",&n,&w)!=EOF && n+w){
104.         //init
105.         memp=0; clr(e); clr(be); clr(hate); clr(cut);
106.         //input
107.         for(k=0;k<w;k++) {
108.             scanf("%d%d",&i,&j); i--;j--;
109.             hate[i][j]=hate[j][i]=1;
110.         }
111.         //create map
112.         for(i=0;i<n;i++) for(j=i+1;j<n;j++) if(!hate[i][j]){
113.             addEdge(e,i,j);
114.             addEdge(e,j,i);
115.         }
116.         //block
117.         m=Block(e,n,cut,be);
118.         
119.         //count
120.         clr(good); count=0;
121.         for(k=0;k<m;k++) Judge(e,be[k],good);
122.         for(i=0;i<n;i++) if(good[i]) count++;
123.         //output
124.         printf("%d/n",n-count);
125.     }
126.     
127.     return 0;
128. }