uva 10746 Crime Wave – The Sequel

最小费用最大流

题意：有n个地点，m部船（m>=n），给出每部船到每个地点的时间。然后要派船到地点。每个船只能用一次即只能去只能去一个地方，每个地方只需要一部船。算出最小平均时间。要算平均时间其实就是算总时间最小，然后除以n即可。那怎么求总时间最小呢？

其实一看，就是匹配类型的问题，但是就我目前学的匹配的算法，没有可以解这道题的，然后是出于白书的图论专题，就考虑是不是可以转化为其他类型的问题来解呢？想起二分图最大匹配问题可以转化为最大流来解，所以很快就想到了用最小费用最大流来解

船从1到m标号，地点从m+1到m+n标号。建立有向图，都是从u船指向v地点，单位费用就是u船到v地点的时间，容量就是1.然后设立一个源点0,0指向所有的船，一共m条边，容量都是1，单位费用都是0.设立一个汇点m+n+1，所有地点指向汇点，单位费用为0容量为1.求源点0到汇点m+n+1的最小费用最大流。可知，最后最大流量为n，最小费用就是最小的总时间，然后除以n即可

这样设立就可以做到每部船和每个地点都只会被用一次（因为最大流满流的边不会再经过，而边容量是1，用一次就会满流）

建图后，直接最小费用最大流模板上去即可

因为是有向图，而且此题不会有平行边，所以邻接矩阵就可以，不用邻接表

#include <cstdio>

#include <cstring>

#include <queue>

#include <cmath>

using namespace std;

#define MAX 50

#define INF 1000000000.00000

#define eps 1e-8

int n,m,F;

double C;

double g[MAX][MAX],cost[MAX][MAX],d[MAX];

int cap[MAX][MAX],flow[MAX][MAX],p[MAX];



void init()

{

    memset(cap,0,sizeof(cap));

    memset(flow,0,sizeof(flow));

    memset(cost,0,sizeof(cost));



    for(int i=1; i<=n; i++)

        for(int j=1; j<=m; j++)

        {

            int u,v;

            u=j; v=m+i;

            cap[u][v]=1;

            scanf("%lf",&cost[u][v]);

            cost[v][u]=-cost[u][v];

        }

    for(int i=1; i<=m; i++)

        cap[0][i]=1;

    for(int i=m+1; i<=m+n; i++)

        cap[i][m+n+1]=1;

}



int relax(int u ,int v)

{

    if(d[v]>d[u]+cost[u][v]+eps)  //精度

        return 1;

    else 

        return 0;

}

void spfa(int s ,int t)

{

    queue<int>q;

    int vis[MAX];

    for(int i=0; i<=m+n+1; i++)

    { d[i]=INF; vis[i]=0; p[i]=-1; }

    d[s]=0; vis[s]=1;

    q.push(s);

    while(!q.empty())

    {

        int u;

        u=q.front(); vis[u]=0; q.pop();

        for(int v=0; v<=m+n+1; v++)

            if(flow[u][v]<cap[u][v] && relax(u,v))  //松弛卡精度

            {

                d[v]=d[u]+cost[u][v];

                p[v]=u;

                if(!vis[v])

                {

                    vis[v]=1;

                    q.push(v);

                }

            }

    }

    return ;

}

void mincost_maxflow()

{

    int s=0,t=m+n+1;

    F=0; C=0;

    while(1)

    {

        spfa(s,t);

        if(d[t]==INF)

            break;

        int u,min=0x3f3f3f3f;

        for(u=t; u!=s; u=p[u])

            min=min < cap[p[u]][u]-flow[p[u]][u] ? min : cap[p[u]][u]-flow[p[u]][u];



        for(u=t; u!=s; u=p[u])  //增广

        {

            flow[p[u]][u]+=min;

            flow[u][p[u]]-=min;

        }

        F+=min;

        C+=1.*min*d[t];

    }



    //printf("%.2lf\n",C);

    //printf("%d\n",F);

    printf("%.2f\n",C/n+eps);  //卡精度

    return ;

}



int main()

{

    while(scanf("%d%d",&n,&m))

    {

        if(!n && !m) break;

        init();

        mincost_maxflow();

    }

    return 0;

}