网络流1飞行员配对方案问题

题目大意：

给定一些外籍飞行员与英国飞行员的配合情况，编程找出一个最佳飞行员的配对情况，使得一次能派出最多的飞机。

题目测试数据与数据范围：

5 10

1 7

1 8

2 6

2 9

2 10

3 7

3 8

4 7

4 8

5 10

－1 －1

4

1 7

2 9

3 8

5 10

其中 n,m<100;

题目分折：

很明显是一个二分图最大匹配问题，我们可以采用的策略有 匈牙利算法（模板），网络流最大流。对匈牙利算法的解（配对方案）输出时，只要遍历一个集合，对于满足有配对的，找到那个boy[i],即可。而对于 网络流问题，

1，可由S向X集合中的每一个顶点连一条容量为 1 的有向边。

2，Y集合中每个顶点向T连一条容量为 1 的有向边。

3，XY集合之间的边都设为 从 A 集合的点到 B 集合之中的点，容量为1 的有向边（即有关系，则连一边）。

我们知道为什么由S 或到达 T 的容量都只设为1，因为这只是一个单重匹配问题，（我们以后还会碰到多生匹配问题，改这容量为无穷大即可），那么我们如何输出解（匹配方案），其实很简单，我们只要遍历 X 的集合，如果以 X 为顶点的 这条边有 流量，那么就是配对的，只要输出这两个顶点即可。

小乐一下：

我认为网络流这种思想的出现，能够使很多东西变得简单，更确切的说，我们可以只要分折一些问题，如何去构造模型，然后套用模板即可。当然有些问题，可能不是那样或者这样的简单而已，（如分层的思想），容量值要怎么去设定。我们一般的方法是拆点，增加 S，T。还有模板我建议用刘汝佳的代码格式，C++里的邻接表，这样做有至少两个好处，1，重边也不怕，2，相当于类的形式了，构造一些边之后，就可以直接调用了，什么都不用管，直接出答案，Dinic 算法进行一次增广时，一次分层，多路增广。

题目代码，更好更简洁的由你们来实现，（模板为刘汝佳代码格式）不要直接复制。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<cstring>
#include<queue>
using namespace std;
const int INF = 0x3fffffff;
const int maxn = 1005;

struct Edge{
    int from,to,cap,flow;
};

struct Dinic{
    int n,m,s,t;
    vector<Edge> edges;
    vector<int> G[maxn];
    bool vis[maxn];
    int d[maxn];
    int cur[maxn];

    void Init(){
        for(int i = 0;i<maxn;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});
        m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }
     bool BFS(){
         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){
         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)))>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){
         this->s = s;
         this->t = t;
         int flow = 0;
         while(BFS()){
            memset(cur,0,sizeof(cur));
            flow += DFS(s,INF);
         }
         return flow;
     }
     void Toans(int n){   // 路径输出，也很方便。
         for(int u = 1;u<=n;u++){
            for(int i = 0;i<G[u].size();i++){
                if(edges[G[u][i]].flow > 0) printf("%d %d\n",u,edges[G[u][i]].to);
            }
         }
     }
};

int main(){
    Dinic Graph;
    int i,u,v,m,n;
    while(scanf("%d%d",&n,&m)!=EOF){
        Graph.Init();
        for(i = n;i>0;i--) Graph.AddEdge(0,i,1);  //构造边的过程。很方便。
        for(i = m;i>n;i--) Graph.AddEdge(i,m+1,1);
        while(scanf("%d%d",&u,&v)!=EOF,u!=-1) Graph.AddEdge(u,v,1);
        printf("%d\n",Graph.Maxflow(0,m+1));
        Graph.Toans(n);
    }
    return 0;
}

伟大的梦想成就伟大的人，从细节做好，从点点滴滴做好，从认真做好。