ACM-ICPC Live Archive 5095 Transportation

最小费用最大流

2010的国赛题，题意很易懂不解释了。

分析部分参考了别人博客：一般的最小费用最大流是给出每个单位流量的费用，计算费用的时候是单位费用*流量，但是这里是单位费用*流量*流量，并不能单纯地计算，要巧妙地拆容量，每条边的原容量为cap，拆成cap条，每条容量都是1，第一次取这条路时是单位费用a，第二次是3*a，依次为5*a,7*a，9*a，这样你会发现，这条路走容量2的话刚好是4a,3为9a，4为16a,5为25a，接下来做一最小费用最大流即可

 

另外注意一点，题中说明边数最大为5000，而每条边的容量最大为5，所以在开数组的时候应该开到 2*5*50000，原来的一条边要拆成cap条边，所以边数变为cap倍，即*5，因为邻接表建图，有向边还要保存它的反边，每条边再*2，一共是*10

 

整道题就是拆边巧妙，其余部分都是最小费用最大流的模板

#include <cstdio>

#include <cstring>

#include <vector>

#include <queue>

#include <algorithm>

using namespace std;

#define INF 0x3f3f3f3f

#define MAXN 110

#define MAXM 5010 //有向图



int nume;

struct edge

{

    int u,v,cap,cost,flow,next;

}e[10*MAXM];

int first[MAXN];

int d[MAXN];  //spfa最短路

int p[MAXN]; //增广记录路径

int N,M,K,S,T;



void add(int u, int v ,int cost ,int cap)

{

    e[nume].u=u; e[nume].v=v; 

    e[nume].cost=cost; e[nume].cap=cap; e[nume].flow=0;

    e[nume].next=first[u]; first[u]=nume++;

}



void build()

{

    memset(first,-1,sizeof(first));

    nume=0;

    S=0; T=N+1;

    //限制最大流为K

    add(S,1,0,K); add(1,S,0,0);

    add(N,T,0,K); add(T,N,0,0);

    for(int i=0; i<M; i++)

    {

        int u,v,cost,cap;

        scanf("%d%d%d%d",&u,&v,&cost,&cap);

        for(int j=1; j<=cap; j++) //拆边的方法

        {//每条边的容量为1,单位费用为(2*j-1)*cost,其实就是1,3,5,7,9

            add(u,v,(2*j-1)*cost,1);

            add(v,u,-(2*j-1)*cost,0);

        }

    }

}



bool spfa()

{

    queue<int>q;

    bool inq[MAXN];

    memset(inq,false,sizeof(inq));

    memset(d,0x3f,sizeof(d));

    memset(p,-1,sizeof(p));

    d[S]=0; q.push(S); inq[S]=true;

    while(!q.empty())

    {

        int u,v,cost,cap,flow;

        u=q.front(); q.pop(); inq[u]=false;

        for(int k=first[u]; k!=-1; k=e[k].next)

        {

            v=e[k].v; cost=e[k].cost; cap=e[k].cap; flow=e[k].flow;

            if(cap>flow && d[u]+cost < d[v])

            {

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

                p[v]=k;

                if(!inq[v])

                {

                    q.push(v);

                    inq[v]=true;

                }

            }

        }

    }

    if(d[T]!=INF) return true;

    return false;

}



void mincost_maxflow()

{

    int FLOW=0,COST=0;

    while(spfa())

    {

        int min=INF;

        for(int k=p[T]; k!=-1; k=p[e[k].u])

            if(e[k].cap-e[k].flow<min) min=e[k].cap-e[k].flow;

        //printf("min=%d\n",min);

        for(int k=p[T]; k!=-1; k=p[e[k].u]) //增广

        {

            e[k].flow += min;

            e[k^1].flow -= min;

        }

        COST += d[T]*min;

        FLOW += min;

    }

    if(FLOW<K)

        printf("-1\n");

    else

        printf("%d\n",COST);

}



int main()

{

    while(scanf("%d%d%d",&N,&M,&K)!=EOF)

    {

        build();

        mincost_maxflow();

    }

    return 0;

}