【LA4043 训练指南】蚂蚁 【二分图最佳完美匹配，费用流】

题意

  给出n个白点和n个黑点的坐标，要求用n条不相交的线段把他们连接起来，其中每条线段恰好连接一个白点和一个黑点，每个点恰好连接一条线段。

分析

  结点分黑白，很容易想到二分图。其中每个白点对应一个X结点，每个黑点对应一个Y点，每个黑点和每个白点相连，权值等于二者的欧几里得距离，建模之后，最佳完美匹配就是问题的解。

  为什么用费用流而不用KM呢，因为我不会···

  

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <vector>
#include <queue>
#include <cmath>

using namespace std;
const int maxN=300;
const int maxm=30000+10;
const int INF=2147480000;
int n;
int ax[maxN],bx[maxN],ay[maxN],by[maxN];

struct MCMF{
    int head[maxN],to[maxm],Next[maxm],from[maxm],flow[maxm],cap[maxm];
    double cost[maxm];
    int n,m,s,t,sz;
    int inq[maxN];
    double d[maxN];
    int p[maxN];
    int a[maxN];

    void init(int n){
        this->n=n;
        sz=-1;
        memset(head,-1,sizeof(head));
    }
    void AddEdge(int a,int b,int ca,double co){
        ++sz;
        to[sz]=b,from[sz]=a,Next[sz]=head[a],head[a]=sz;
        flow[sz]=0,cap[sz]=ca,cost[sz]=co;
        ++sz;
        to[sz]=a,from[sz]=b,Next[sz]=head[b],head[b]=sz;
        flow[sz]=ca,cap[sz]=ca,cost[sz]=-co;
    }
    bool BellmanFord(int s,int t,int &Flow,double &Cost){
        for(int i=0;i<=n;i++)d[i]=INF;
        memset(inq,0,sizeof(inq));
        d[s]=0;inq[s]=1;p[s]=-1;a[s]=INF;
        queue<int>Q;
        Q.push(s);
        while(!Q.empty()){
            int u=Q.front();Q.pop();
            inq[u]=0;
            for(int i=head[u];i!=-1;i=Next[i]){
                int v=to[i];
                if(cap[i]>flow[i]&&d[v]>d[u]+cost[i]){
                    d[v]=d[u]+cost[i];
                    p[v]=i;
                    a[v]=min(a[u],cap[i]-flow[i]);
                    if(!inq[v]){
                        Q.push(v);
                        inq[v]=1;
                    }
                }
            }
        }
        if(d[t]==INF)return false;
        Flow+=a[t];
        Cost+=d[t]*(double)a[t];
        int u=t;

        while(u!=s){
            flow[p[u]]+=a[t];
            flow[p[u]^1]-=a[t];
            u=from[p[u]];
        }
        return true;
    }

    double Mincost(int s,int t){
        int Flow=0;
        double Cost=0;
        while(BellmanFord(s,t,Flow,Cost));
        return Cost;
    }
}mcmf;

double dist(int X,int Y){
    return sqrt((double)(ax[X]-bx[Y])*(ax[X]-bx[Y])+(double)(ay[X]-by[Y])*(ay[X]-by[Y]));
}
int main(){
    while(scanf("%d",&n)!=EOF){
        for(int i=1;i<=n;i++)
            scanf("%d%d",&ax[i],&ay[i]);
        for(int i=1;i<=n;i++)
            scanf("%d%d",&bx[i],&by[i]);
        mcmf.init(2*n+2);
        for(int i=1;i<=n;i++)
            mcmf.AddEdge(0,i,1,0);
        for(int i=1;i<=n;i++)
            mcmf.AddEdge(i+n,2*n+1,1,0);
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                mcmf.AddEdge(i,j+n,1,dist(i,j));
            }
        }
        mcmf.Mincost(0,2*n+1);
        for(int i=1;i<=n;i++){
            for(int j=mcmf.head[i];j!=-1;j=mcmf.Next[j]){
                if(j%2)continue;
                int v=mcmf.to[j];
                if(mcmf.cap[j]==mcmf.flow[j]){
                    printf("%d
",v-n);
                    break;
                }
            }
        }
    }
    return 0;
}