poj 3084 最小割

题意：

有一些用门相连的小房间，门可以开关，但是每个门的开关只能由给定的某一个房间控制,现在给定一个房间t和一些房间mi，问使得mi到s都不连通的情况下，需要关闭的门的最少个数。

思路：

房间看作点，门看作边，若门可以随意开关，在点之间连容量为1的双向边表示门，最小边割集的容量即为答案。但题中表示门只可由一方控制，也就是说若存在a->b的边，且门由a控制，那么我们在求解最小割的过程中边a->b就不能成为割集中的边。反之，边b->a可以。回忆以最大流的方式求解最小割的过程中，割集中的边一定是那些流量f等于容量的边，也就是在残余网络中不存在的边。我们可以将边a->b的容量定为inf,来保证增广过程中a->b不会满流，也就不会成为割集中的边。另外，对于多个源点，增加新的源点s’向他们连容量为inf的边，同理，这些边也不能成为割集中的边。最后求解s’到t的最大流可解。若原图中可增广从s’到t的流量为inf的流，那么原问题无解。

个人注意：

理解最大流最小割的关系，若原图中有些边不能被割，可设其容量为inf.

代码：

#include <cstdio>
#include <queue>
#include <cstring>
#include <vector>
using namespace std;
const int inf = 500;
const int max_v = 40;
struct edge{int to,cap,rev;};
vector<edge> G[max_v];
int level[max_v];
int iter[max_v];
void add_edge(int from ,int to ,int cap)
{
    G[from].push_back((edge){to,cap,G[to].size()});
    G[to].push_back((edge){from,0,G[from].size()-1});
}
void bfs(int s)
{
    memset(level,-1,sizeof(level));
    queue<int> que;
    level[s] = 0;
    que.push(s);
    while(!que.empty())
    {
        int v = que.front();que.pop();
        for(int i = 0; i < G[v].size();i++)
        {
            edge &e =G[v][i];
            if(e.cap > 0&& level[e.to]<0)
            {
                level[e.to] = level[v]+1;
                que.push(e.to);
            }
        }
    }
}
int dfs(int v,int t,int f)
{
    if(v == t) return f;
    for(int &i = iter[v]; i < G[v].size();i++)
    {
        edge &e = G[v][i];
        if(e.cap > 0 && level[v] < level[e.to])
        {
            int d = dfs(e.to,t,min(f,e.cap));
            if(d > 0)
            {
                e.cap-=d;
                G[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}
int max_flow(int s,int t)
{
    int flow = 0;
    while(1)
    {
        bfs(s);
        if(level[t] < 0) return flow;
        memset(iter, 0 ,sizeof(iter));
        int f;
        while((f = dfs(s,t,inf)) > 0)
        {
            flow+=f;
        }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        for(int i = 0; i < max_v;i++)
            G[i].clear();
        int m,n;
        scanf("%d%d",&m,&n);
        for(int i = 0; i < m; i++)
        {
            char sp[5];
            scanf("%s",sp);
            if(sp[0] == 'I')
                add_edge(m, i,inf);
            int cnt;
            scanf("%d",&cnt);
            for(int j = 0; j < cnt;j++)
            {
                int a;
                scanf("%d",&a);
                add_edge(i, a,inf);
                add_edge(a,i,1);
            }
        }
        int ans = max_flow(m,n);
        if(ans < inf)
            printf("%d\n",ans);
        else
            printf("PANIC ROOM BREACH\n");
    }
    return 0;
}