[网络流24题]负载平衡问题 （费用流）

题目描述

G公司n个沿铁路运输线环形排列的仓库，每个仓库存储的货物数量不等。如何用最少搬运量可以使n 个仓库的库存数量相同。搬运货物时，只能在相邻的仓库之间搬运。
输入输出格式
输入格式：
文件的第1 行中有1 个正整数 n ，表示有 n 个仓库。第 2 行中有 n 个正整数，表示 n 个仓库的库存量。
输出格式：
输出最少搬运量。

题解

很明显，题目中要求运送的货物最少，我们不妨设运送货物是需要成本的，而我们需要在货物达到规定量的同时，成本最小，也就是流量最大时，费用最小。转化成了最小非用最大流问题。

我们再来看这道题的限制性条件。
我们能发现，如果货物数量都相等，那么这个相等的数量肯定是货物的平均数，那么我们把所有的货物都减去一个平均数，那么如果是正数就说明需要运送到其他地方去，如果是负数那就说明需要其他地方运过来。
我们不妨设s为超级源点，t为超级汇点。
那么对于每一个负数，我们都从超级源点连一条边到它，但是费用0，代表它需要那么多货物；对于每一个正数，我们都从它向超级汇点连一条边，但是费用为0，代表它需要运走那么多货物。
相邻两个货物堆之间需要连一条容量为无穷大，费用为1的边，代表可以无限运输，但是有代价。

这样，最大流的情况一定是：源点发出的边全部满流，到汇点的边也全部满流。
GG
下面看代码：

code

#include<bits/stdc++.h>
using namespace std;
inline int read(){
    int num=0;char c=' ';bool flag=true;
    for(;c>'9'||c<'0';c=getchar())
        if(c=='-')
            flag=false;
    for(;c>='0'&&c<='9';num=(num<<3)+(num<<1)+c-48,c=getchar());
    return flag ? num : -num;
}
namespace graph{
    const int maxn=1200;
    struct node{
        int y,val,next,cost;
    }a[maxn<<3];
    int head[maxn],thing[maxn],top=0;
    void insert(int x,int y,int v,int c){
        a[top].y=y;
        a[top].next=head[x];
        a[top].val=v;
        a[top].cost=c;
        head[x]=top++;
    }
    int n,s,t;
    const int INF=0x7fffffff;
    void init(){
    //这里的建图最关键，最费脑 
        memset(head,-1,sizeof head);
        n=read();
        s=0;t=n+1;
        //0号源点，n+1号汇点。 
        int sum=0;
        for(int i=1;i<=n;i++){
            thing[i]=read();
            sum+=thing[i];
        }
        sum/=n;
        for(int i=1;i<=n;i++){
            thing[i]-=sum;
            if(thing[i]>0){
                insert(s,i,thing[i],0);
                insert(i,s,0,0);
            }
            if(thing[i]<0){
                insert(i,t,-thing[i],0);
                insert(t,i,0,0);
            }
        }
        for(int i=2;i<n;i++){
            insert(i,i+1,INF,1);
            insert(i+1,i,0,-1);
            insert(i,i-1,INF,1);
            insert(i-1,i,0,-1);
        }
        insert(1,2,INF,1);
        insert(2,1,0,-1);
        insert(1,n,INF,1);
        insert(n,1,0,-1);

        insert(n,1,INF,1);
        insert(1,n,0,-1);
        insert(n,n-1,INF,1);
        insert(n-1,n,0,-1);
        //由于是环，所以1号和n号需要特殊处理 
    }
}using namespace graph;

namespace min_cost_max_flow{
    int dis[maxn],flow[maxn],pre[maxn],mincost=0,maxflow=0;
    bool vis[maxn];
    bool spfa(){
        memset(dis,0x7f,sizeof dis);
        memset(vis,0,sizeof vis);
        queue<int>q;
        while(!q.empty())q.pop();
        q.push(s);
        vis[s]=true;
        dis[s]=0;
        flow[s]=0x7f7f7f7f;
        while(q.size()){
            int u=q.front();
            q.pop();
            vis[u]=false;
            for(int i=head[u];i+1;i=a[i].next)
                if(dis[a[i].y]>dis[u]+a[i].cost && a[i].val){
                    int v=a[i].y;
                    dis[v]=dis[u]+a[i].cost;
                    flow[v]=min(flow[u],a[i].val);
                    pre[v]=i;
                    if(!vis[v]){
                        vis[v]=true;
                        q.push(v);
                    }
                }
        }
        return dis[t]!=0x7f7f7f7f;
    }
    void updata(){
        int x=t;
        while(x!=s){
            int i=pre[x];
            a[i].val-=flow[t];
            a[i^1].val+=flow[t];
            x=a[i^1].y;
        }
        maxflow+=flow[t];
        mincost+=flow[t]*dis[t];
    }
}using namespace min_cost_max_flow;
//最小费用最大流的模板 ..不用多解释 
int main(){
    init();
    while(spfa())updata();
    printf("%d\n",mincost);
    return 0;
}