poj 3084 zoj2788 边联通度，最大流

/*
边联通度的题；给定n个门，每个门连接两个房间，门面向其中的一个房间x，从这个房间x任意情况都可以到另外一个房间y,y只能在门开着的时候可以进入x,其中有些房间有入侵者，现在求解至少关几个门，可以保护某个房间的安全
对于x,y之间面向x的门，连x到y的边，流量无穷，y到x的边，流量1
连接源点到有入侵者的点，流量无穷，要保护的点作为汇点
如果最大流为无穷，则不存在保护方案，反之，最大流即是最少要关的门的数量
*/
#include <stdio.h>
#include <iostream>
#include <string.h>
#include<queue>
#include<cmath>
using namespace std;
const int maxn=50,maxe=50000;
const __int64 INF=(1LL)<<60;
const __int64 inf=(1LL)<<60;
#define LL __int64
//******************************
struct edge    
{     
    int v, next;     
    LL val;     
} net[ 500010 ];     
int n,m;  
int level[maxn], Qu[maxn], out[maxn],next[maxn];    
class Dinic {     
public:     
    int end;    
    Dinic() {     
        end = 0;     
        memset( next, -1, sizeof(next) );     
    }     
    inline void insert( int x, int y, LL c) {     
        net[end].v = y, net[end].val = c,    
        net[end].next = next[x],     
        next[x] = end ++;     
        net[end].v = x, net[end].val = 0,    
        net[end].next = next[y],     
        next[y] = end ++;     
    }     
    bool BFS( int S, int E ) {     
        memset( level, -1, sizeof(level) );     
        int low = 0, high = 1;     
        Qu[0] = S, level[S] = 0;     
        for( ; low < high; ) {     
            int x = Qu[low];     
            for( int i = next[x]; i != -1; i = net[i].next ) {     
                if( net[i].val == 0 ) continue;     
                int y = net[i].v;     
                if( level[y] == -1 ) {     
                    level[y] = level[x] + 1;     
                    Qu[ high ++] = y;     
                }     
            }     
            low ++;     
        }     
        return level[E] != -1;     
    }      
      
    LL MaxFlow( int S, int E ){     
        LL maxflow = 0;     
        for( ; BFS(S, E) ; ) {     
            memcpy( out, next, sizeof(out) );     
            int now = -1;     
            for( ;; ) {     
                if( now < 0 ) {     
                    int cur = out[S];     
                    for(; cur != -1 ; cur = net[cur].next )      
                        if( net[cur].val && out[net[cur].v] != -1 && level[net[cur].v] == 1 )     
                            break;     
                    if( cur >= 0 ) Qu[ ++now ] = cur, out[S] = net[cur].next;     
                    else break;     
                }     
                int u = net[ Qu[now] ].v;     
                if( u == E ) {     
                    LL flow = inf;     
                    int index = -1;     
                    for( int i = 0; i <= now; i ++ ) {     
                        if( flow > net[ Qu[i] ].val )     
                            flow = net[ Qu[i] ].val, index = i;     
                    }     
                    maxflow += flow;     
                    for( int i = 0; i <= now; i ++ )     
                        net[Qu[i]].val -= flow, net[Qu[i]^1].val += flow;     
                    for( int i = 0; i <= now; i ++ ) {     
                        if( net[ Qu[i] ].val == 0 ) {     
                            now = index - 1;     
                            break;     
                        }     
                    }     
                }     
                else{     
                    int cur = out[u];     
                    for(; cur != -1; cur = net[cur].next )      
                        if (net[cur].val && out[net[cur].v] != -1 && level[u] + 1 == level[net[cur].v])     
                            break;     
                    if( cur != -1 )     
                        Qu[++ now] = cur, out[u] = net[cur].next;     
                    else out[u] = -1, now --;     
                }     
            }     
        }     
        return maxflow;     
    }     
};     
//******************************
char c[3];
int main()
{
	int ca,num,tmp;
	scanf("%d",&ca);
	while(ca--)
	{
		Dinic my;
		scanf("%d%d",&n,&m);
		for(int i=0;i<n;i++)
		{
			scanf("%s",c);
			if(c[0]=='I')
			my.insert(0,i+1,INF);
			scanf("%d",&num);
			while(num--)
			{
				scanf("%d",&tmp);
				my.insert(i+1,tmp+1,INF);
				my.insert(tmp+1,i+1,1);
			}
		}
		__int64 ans=my.MaxFlow(0,m+1);
		if(ans>=INF)
		puts("PANIC ROOM BREACH");
		else 
		printf("%I64d\n",ans);
	}
    return 0;
}