负载平衡问题（网络流之费用流的应用）

负载平衡问题

题目描述

$G$ 公司有 $n$ 个沿铁路运输线环形排列的仓库，每个仓库存储的货物数量不等。如何用最少搬运量可以使 $n$ 个仓库的库存数量相同。搬运货物时，只能在相邻的仓库之间搬运。

输入格式

第一行一个正整数 $n$，表示有 $n$ 个仓库。

第二行 $n$ 个正整数，表示 $n$ 个仓库的库存量。

输出格式

输出最少搬运量。

样例 #1

样例输入 #1

5
17 9 14 16 4

样例输出 #1

11

提示

$1\le n\le 100$。

思路

题意：
我们直接想，因为你题目要让所有仓库的货物最终数量相等，那么我们的仓库货物数量最终就等于这些货物总和的平均数。那么，此时我们可以分成两大类，一个是 $a_i>x$，另一个是 $a_i<x$，其中 $x$ 是货物数量的平均数。

那么这样我们就可以按照上一题的方法来做了，把 $>x$ 和 $<x$ 的分成两大类。但本道题跟上一道题不一样的是，这道题不是一个经典的二分图（因为某个仓库只能向相邻两个仓库连边），因为它可能出现下图所示的情况：
注意：我们都是从剩余的流到需要的。

运多少货物就在对应的边上设置多少流量就行了。而且我们最后肯定是满流的，因为所有多的肯定会流量所有缺的。

如果给定满流，我们可以看中间的边的流量，这个流量就等价于我运了多少货物。

其实要证明元素相等，其实就是证明（对于本道题）运输和流之间的等价（近似）关系。

如果等价的话，那么此时的数量关系一般也是等价的，比如本道题因为是等价关系（就是原问题的每一组解都能对应到流网络的每一组解），因此数量关系：只要求最大费用流就能求出原问题的最大费用了。

---

拓展

细节：

• 如果对于求最大流的时候，出现无向边的话：

此时我们可以合并两条边。

• 如果是求费用流的话，则不能合并，如上图所示：从 $a\to b$ 一个费用是 $1$，另一个费用是 $-1$，费用不一样，不能合并。

代码

//这道题很特殊，因为它是跟相邻的有关系
//而且本道题最终是满流，因为肯定要从多的流到少的
//还有就是要记住，容量一般不设置为0

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>

using namespace std;

const int N = 210,M = (N*2+N*N)*2+10,INT = 1e8;

int e[M],ne[M],f[M],w[M],h[N],idx;
bool st[N];
int pre[N],d[N],incf[N];
int n,m,S,T;
int tot;
int cost[N];

void add(int a,int b,int c,int d){
    e[idx]=b,f[idx]=c,w[idx]=d,ne[idx]=h[a],h[a]=idx++;
    e[idx]=a,f[idx]=0,w[idx]=-d,ne[idx]=h[b],h[b]=idx++;
}

bool spfa(){
    queue<int>q;
    q.push(S);
    
    memset(incf,0,sizeof incf);
    memset(d,0x3f,sizeof d);
    
    d[S]=0,incf[S]=INT;
    
    while(q.size()){
        int t=q.front();
        q.pop();
        st[t]=false;
        
        for(int i=h[t];~i;i=ne[i]){
            int ver=e[i];
            
            if(f[i]>0&&d[ver]>d[t]+w[i]){
                d[ver]=d[t]+w[i];
                incf[ver]=min(f[i],incf[t]);
                pre[ver]=i;
                if(!st[ver]){
                    st[ver]=true;
                    q.push(ver);
                }
            }
        }
    }
    return incf[T]>0;
}

int EK(){
    int cost=0;
    
    while(spfa()){
        int t=incf[T];
        cost+=t*d[T];
        
        for(int i=T;i!=S;i=e[pre[i]^1]){
            f[pre[i]]-=t;
            f[pre[i]^1]+=t;
        }
    }
    return cost;
}

int main(){
    cin>>n;
    
    memset(h,-1,sizeof h);
    
    S=0,T=n+1;
    
    for(int i=1;i<=n;i++){
        cin>>cost[i];
        tot+=cost[i];
    }
    
    int t=tot/n;
    
    for(int i=1;i<=n;i++){
        if(t-cost[i]<0)add(S,i,cost[i]-t,0);
        else if(t-cost[i]>0){
            add(i,T,t-cost[i],0);
        }
    }
    
    for(int i=1;i<=n;i++){
        add(i,i<n?i+1:1,INT,1);
        add(i,i>1?i-1:n,INT,1);
    }
    
    
    cout<<EK();
    
    return 0;
    
}