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
来源
NYIST第一届校赛(专业组)

间谍所在点作为源点，N作为汇点，容量设为1，流量设为0，枚举源点到汇点的最大流，累加输出即可

代码

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include<string.h>
using namespace std;
//稍后改用邻接表
const int maxn=205;
const int INF=0x3f3f3f3f;
struct node
{
    int c;
    int f;
} map[maxn][maxn];
int path[maxn];
int alpha[maxn];
int vis[maxn];
int point[maxn];//存放间谍所在点
int N;//城市数量
int M;//道路数量
int P;//与汇点相连城市的标号
int Find_Path(int star,int end)//传入源点和汇点，返回最大可改进量
{
    memset(path,-1,sizeof(path));
    memset(alpha,0,sizeof(alpha));
    memset(vis,0,sizeof(vis));
    queue<int>q;
    q.push(star);
    vis[star]=1;//起点已被增广
    path[star]=star;
    alpha[star]=INF;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=1; i<=N; i++)
        {
            if(vis[i]==0)
            {
                if(map[u][i].c-map[u][i].f>0)
                {
                    alpha[i]=min(alpha[u],map[u][i].c-map[u][i].f);
                    path[i]=u;
                    vis[i]=1;
                    q.push(i);
                }
                else if(map[i][u].f>0&&map[i][u].c>0)
                {
                    vis[i]=1;
                    path[i]=u;
                    alpha[i]=map[i][u].f;
                    q.push(i);
                }
            }
        }
    }
    return alpha[N];
}
void Update(int star,int end)//更新网络流,传入源点和汇点
{
    for(int i=end; i!=star; i=path[i])
    {
        if(map[path[i]][i].c-map[path[i]][i].f>0)
            map[path[i]][i].f+=alpha[N];
        else if(map[i][path[i]].c>0&&map[i][path[i]].f>0)
            map[i][path[i]].f-=alpha[N];
    }
}
int main()
{
    int T;
    scanf("%d",&T);
    for(int casen=1; casen<=T; casen++)
    {
        memset(map,0,sizeof(map));
        scanf("%d%d%d",&N,&M,&P);
        for(int i=0; i<P; i++)
            scanf("%d",&point[i]);
        while(M--)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            map[u][v].c=1;
            map[u][v].f=0;
            map[v][u].c=1;
            map[v][u].f=0;//无向图
        }
        int max_flow=0;
        //打算枚举源点
        for(int i=0; i<P; i++)
        {
            while(1)
            {
                int flag=Find_Path(point[i],N);
                if(flag==0)
                    break;
                max_flow+=flag;
                Update(point[i],N);
            }
        }
        printf("Case #%d: %d\n",casen,max_flow);

//        for(int i=0; i<=N; i++)
//        {
//            for(int j=0; j<=N; j++)
//                printf("%d ",map[i][j].f);
//            printf("\n");
//        }
//        printf("\n");
//        for(int i=0; i<=N; i++)
//        {
//            for(int j=0; j<=N; j++)
//                printf("%d ",map[i][j].c);
//            printf("\n");
//        }
    }
    return 0;
}