线性规划与网络流24题の19 负载平衡问题（最小费用最大流）

n个仓库排成一圈，每个仓库中有一些货物，货物可以在相邻的仓库之间搬运。先要使仓库里的货物数量相等，求最小的搬运量。

http://wikioi.com/problem/1916/

转化成供求平衡的问题。

先求出货物的平均值aver，建立二分图，吧每个仓库拆成两个点：供应节点X和需求节点Y。

如果ai - aver > 0,就从源点向Xi连一条容量为ai - aver，费用为0的边；

如果ai - aver < 0,就从Yi向汇点连一条容量为aver - ai，费用为0的边；

如果i和j相邻，就从Xi向Yj连一条容量为inf费用为1的边，表示搬运一个货物需要的费用为1。并从Xi向Xj连一条容量为inf，费用为1的边，表示暂时运过去，不立即满足需求。

然后求最小费用最大流即可。

//#pragma comment(linker,"/STACK:1024000000,1024000000")
#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <cstdio>
#include <string>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

typedef double DB;
typedef long long ll;
typedef pair<int, int> PII;

#define pb push_back
#define MP make_pair
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

const DB eps = 1e-6;
const int inf = ~0U>>1;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1000000007;
const int maxn = 1000 + 10;


/*mincost 为最小费用。若要求最大费用，加边时将费用取反，最后-mincost是最大费用*/
///先调用init，然后while(Find());
const int maxv = 1000 + 10;///顶点数
const int maxe = 1000000 + 10;///边数
struct node{
    int v, w, cap, next; ///cap = 容量, w = 费用
}edge[maxe];
struct fnode{
    int e, cap, w;///上一条边，容量，费用
}fn[maxv];
int head[maxv], cnt, st, ed, maxflow, mincost;
bool vis[maxv];
void addedge(int u, int v, int cap, int w){
    edge[cnt].v = v; edge[cnt].w = w; edge[cnt].cap = cap; edge[cnt].next = head[u]; head[u] = cnt++;
    edge[cnt].v = u; edge[cnt].w = -w; edge[cnt].cap = 0; edge[cnt].next = head[v]; head[v] = cnt++;
//    printf("u:%d, v:%d, cap:%d, w:%d, cnt:%d\n", u, v, cap, w, cnt - 1);
}
bool Find(){///找最短路
    memset(vis, false, sizeof(vis));
    for(int i=st; i<=ed; i++) fn[i].w = inf;
    fn[st].w = 0;
    vis[st] = 1; fn[st].cap = inf;
    queue<int> Q;
    Q.push(st);
    while(!Q.empty()){
        int now = Q.front(); Q.pop();
        vis[now] = 0;
        for(int i=head[now]; ~i; i=edge[i].next){
            int k = edge[i].v;
            if(edge[i].cap && fn[now].w + edge[i].w < fn[k].w){
                fn[k].w = fn[now].w + edge[i].w;
                fn[k].cap = min(fn[now].cap, edge[i].cap);
                fn[k].e = i;
                if(!vis[k]){
                    vis[k] = 1; Q.push(k);
                }
            }
        }
    }
    if(fn[ed].w == inf) return 0;
    mincost += fn[ed].cap * fn[ed].w;
    maxflow += fn[ed].cap;
    int i = ed;
    while(i != st){
        edge[fn[i].e].cap -= fn[ed].cap;
        edge[fn[i].e ^ 1].cap += fn[ed].cap;
        i = edge[fn[i].e ^ 1].v;
    }
    return 1;
}
void init(int source, int sink){
    memset(head, -1, sizeof(head)); cnt = 0;
    st = source; ed = sink;///源点和汇点
    maxflow = mincost = 0;///最大流和最小费用
}

int n, a[maxn];
int main(){
    scanf("%d", &n);
    init(0, 2 * n + 1);
    int sum = 0;
    for(int i=1; i<=n; i++){
        scanf("%d", &a[i]);
        sum += a[i];
    }
    sum /= n;
    for(int i=1; i<=n; i++){
        if(a[i] - sum > 0) addedge(st, i, a[i] - sum, 0);
        else if(a[i] - sum < 0) addedge(i + n, ed, sum - a[i], 0);
        int l = i + 1, r = i - 1;
        if(i == 1) r = n;
        if(i == n) l = 1;
        addedge(i, l, inf, 1); addedge(i, l + n, inf, 1);
        addedge(i, r, inf, 1); addedge(i, r + n, inf, 1);
    }
    while(Find());
    printf("%d\n", mincost);
    return 0;
}