POJ 3084 Panic Room

POJ 3084 Panic Room

网络流

传送门：POJ

---

题意

• 有N个房间（编号从0到N-1）和一些连通这些房间的门，在这N个房间里面有一个特殊的房间M。
• 现在有一些入侵者入侵到一些房间，为了保护房间M不被入侵者入侵，我们需要锁上一些门使得这些入侵者不能到达房间M。
• 输入有N行分别代表每个房间的信息。
• 每一行行开头有一个字符串，若为NI表示该房间没有被入侵，反之说明该房间已经被入侵。
• 字符串后面有一个整数num，后面跟着num个整数，表示房间的编号，代表当前房间到这num个房间有一个门。
• 特别的，房间a -> b之间有一个门。若门没有上锁，a可以到达b，b也可以到达a；在门上锁后，a依旧可以到达b，但是b不能到达a。
• 给你以上信息，让你求出保护房间M不被入侵需要锁上的最少门数，若无法保护输出PANIC ROOM BREACH。

---

思路

• 网络流。重点在建图。
• 添加超级源，超级源连边到所有入侵者所在的房间。
• A到B有门，那么添加一条A到B的，容量为无穷的边，B到A容量为1的边。
• 然后跑dinic，如果最大流是无穷，说明没发保护房间，否则只要把最大流的门锁上(最大流等于最小割)，就能保护房间。因为入侵者想到房间，必须经过最大流所在边。
• 说明一下边容量的意义。锁上一个A到B的门，A还能到B，所以A到B容量是无穷。而B不能到A，所以B到A容量是1。因为成为最小割的只能是容量为1的边。

---

代码

#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<string>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
using namespace std;
const int MAXN=3007;
const int oo=0x3f3f3f3f;
const long long int loo=9223372036854775807ll;
typedef long long LL;
struct Dinic
{
    struct Edge{
        int from, to, cap, flow;//cap容量 flow流量
        Edge(){}
        Edge(int u, int v, int c, int f){ from=u;to=v;cap=c;flow=f; }
    }e[MAXN];
    vector<Edge> edges;//顺序的插入边
    vector<int> G[MAXN];//保存边号
    bool vis[MAXN];//BFS使用
    int d[MAXN];
    int cur[MAXN];
    void init(int n)
    {
        for(int i=0;i<n;i++) G[i].clear();
        edges.clear();
    }

    void AddEdge(int from, int to, int cap)
    {
        edges.push_back(Edge(from, to, cap, 0));
        edges.push_back(Edge(to, from, 0, 0));//单向边第三个参数写0，双向边写cap
        int t_m=edges.size();
        G[from].push_back(t_m-2);
        G[to].push_back(t_m-1);
    }

    bool BFS(int s, int t)
    {
        memset(vis, 0, sizeof(vis));
        queue<int> Q;
        Q.push(s);
        d[s]=0;
        vis[s]=1;
        while(!Q.empty())
        {
            int x=Q.front();Q.pop();
            for(int i=0;i<G[x].size();i++)
            {
                Edge& e=edges[G[x][i]];
                if(!vis[e.to]&&e.cap>e.flow)//残量网络
                {
                    vis[e.to]=1;
                    d[e.to]=d[x]+1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }
    int DFS(int x, int a, int s, int t)
    {
        if(x==t||a==0) return a;
        int flow=0, _f;
        for(int& i=cur[x];i<G[x].size();i++)
        {
            Edge& e=edges[G[x][i]];
            if(d[x]+1==d[e.to]&&(_f=DFS(e.to, min(a, e.cap-e.flow), s, t))>0)
            {
                e.flow+=_f;
                edges[G[x][i]^1].flow-=_f;
                flow+=_f;
                a-=_f;
                if(a==0) break;
            }
        }
        return flow;
    }
    int Maxflow(int s, int t)
    {
        int flow=0;
        while(BFS(s, t))
        {
            memset(cur, 0, sizeof(cur));
            flow+=DFS(s, oo, s, t);
        }
        return flow;
    }
};

int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        Dinic dinic;
        dinic.init(30);
        int n, m;
        scanf("%d%d", &n, &m);
        const int sup_s=25;
        const int sup_t=m;
        for(int i=0;i<n;i++)
        {
            char ss[5];
            int t_m;
            scanf("%s%d", ss, &t_m);
            if(ss[0]=='I')
            {
                dinic.AddEdge(sup_s, i, oo);
            }
            for(int j=0;j<t_m;j++)
            {
                int temp;
                scanf("%d", &temp);
                dinic.AddEdge(i, temp, oo);
                dinic.AddEdge(temp, i, 1);
            }
        }
        int ma=dinic.Maxflow(sup_s, sup_t);
        if(ma>=oo) printf("PANIC ROOM BREACH\n");
        else printf("%d\n", ma);
    }
    //system("pause");
    return 0;
}