nyoj 677 碟战(最大流最小割定理)

碟战

时间限制： 2000 ms  |  内存限制： 65535 KB

难度： 4

描述

知己知彼，百战不殆！在战争中如果被敌人掌握了自己的机密，失败是必然的。K国在一场战争中屡屡失败，就想到自己的某些城市可能会有敌方的间谍。

在仔细调查后，终于得知在哪些城市存在间谍。当然这个消息也被敌方间谍得知，所以间谍们开始撤离，试图到达K国唯一机场，然后抢夺飞机回国。由于城市内部比较复杂，K国领导人决定封锁道路，阻止所有间谍到达机场。城市编号为1~N，两个城市有不超过1条双向道路相连。机场在N号城市，不会有间碟。

由于要节约兵力，至少要封锁多少条道路才能阻止所有间谍到达机场？

输入

第一行包含一个整数T（T <= 100)，为测试数据组数。
接下来每组测试数据第一行包含三个整数n,m,p（2<= n <= 200,1< m < 20000,1 <= p < n),分别表示城市数量，道路数量，存在间谍的城市的数量。
接下来的一行包含p个整数x（1 <= x < n),表示存在间谍城市的编号。
接下来的m行，每行包含两个整数i,j，表示城市i与城市j有道路相通。

输出

输出“Case #i: ans”(不含引号),i为第i组数据，ans为需要封锁道路的条数。

样例输入

2
4 4 2
1 2
1 2
2 4
1 3
3 4
4 3 2
1 2
2 3
3 4
2 4

样例输出

Case #1: 2
Case #2: 2

解题思路：简单的最大流最小割定理，设置一个超级源点，与所有有间谍的城市连一条边，容量为无穷大，表示不会去割这条边，然后其它边不变，容量为1，注意要连双向边，汇点为N号节点。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;

const int maxn = 1000;
const int INF = 0x3f3f3f3f;
struct Edge
{
	int to,next,flow;
}edge[160005];
int n,m,p;
int head[maxn],level[maxn],cnt;

void addedge(int u,int v,int flow)  
{  
    edge[cnt].to = v;  
    edge[cnt].flow = flow;  
    edge[cnt].next = head[u];  
    head[u] = cnt++;  
    swap(u,v);  
    edge[cnt].to = v;  
    edge[cnt].flow = 0;  
    edge[cnt].next = head[u];  
    head[u] = cnt++;  
}  

int BFS(int src,int des){  
    queue<int>q;  
    memset(level,0,sizeof(level));  
    level[src]=1;  
    q.push(src);  
    while(!q.empty()){  
        int u = q.front();  
        q.pop();  
        if(u==des) return 1;  
        for(int k = head[u];k!=-1;k=edge[k].next){  
            int v = edge[k].to,w=edge[k].flow;  
            if(level[v]==0&&w!=0){  
                level[v]=level[u]+1;  
                q.push(v);  
            }  
        }  
    }  
    return -1;  
}  

int dfs(int u,int des,int increaseRoad){  
    if(u==des) return increaseRoad;  
    int ret=0;  
    for(int k=head[u];k!=-1;k=edge[k].next){  
        int v = edge[k].to,w=edge[k].flow;  
        if(level[v]==level[u]+1&&w!=0){  
            int MIN = min(increaseRoad-ret,w);  
            w = dfs(v,des,MIN);  
            if(w > 0)  
            {  
                edge[k].flow -= w;  
                edge[k^1].flow += w;  
                ret+=w;  
                if(ret==increaseRoad) return ret;  
            }  
            else level[v] = -1;   
        }  
    }  
    return ret;  
}  

int Dinic(int src,int des){  
    int ans = 0;  
    while(BFS(src,des)!=-1) ans+=dfs(src,des,INF);  
    return ans;  
}  

int main()
{
	int t,u,v,cas = 1;
	scanf("%d",&t);
	while(t--)
	{
		cnt = 0;
		memset(head,-1,sizeof(head));
		scanf("%d %d %d",&n,&m,&p);
		for(int i = 1; i <= p; i++)
		{
			scanf("%d",&u);
			addedge(0,u,INF);
		}
		for(int i = 1; i <= m; i++)
		{
			scanf("%d %d",&u,&v);
			addedge(u,v,1);
			addedge(v,u,1);
		}
		printf("Case #%d: %d\n",cas++,Dinic(0,n));
	}
	return 0;
}