洛谷 P 4016

题目链接：负载平衡问题

最小费用最大流 这篇博客挺好的！

关于构图：

首先，这是一道最小费用（费用指在两个相邻仓库中的运输单价）最大流的题目。

1.必不可少的有一个超级源点和汇点，st=0,ed=n+1。

2.贪心的想，为了是所有仓库的数量都相等，就应该讲多余平均值的仓库运往少于平均值的仓库，自然而然就想到多的仓库应该贡献，连向源点；少的仓库应该得到，连向汇点，且费用为0（因为费用指在两个相邻仓库中的运输单价）。

3.另外，相邻的节点之间也要建边，对于两个相邻的节点，我们应该连上一条流量为INF（可以无限运输），费用为1的边，因为是无向图，所以应该建双向边，注意：还要建反向边。

4.注意：本题为环，所以1号节点与n号节点还应特殊处理（参照3）。

#include<cstdio>
#include<queue>
#include<iostream>
#include<cstring>
#include<queue>
#include<algorithm>
#define INF 2147483647
using namespace std;
queue<int> q;
int n,m,len=0,st,ed;
struct node
{
    int x,y,c,d,next;
} a[10000];
int b[10000],last[10000],dis[10000],pre[10000],pos[10000],p[10000];
bool bz[10000];
void ins(int x,int y,int c,int d) //从 x 到 y 流量为 c 花费为 d 
{
    a[len].x=x;
    a[len].y=y;
    a[len].c=c;
    a[len].d=d;
    a[len].next=last[x];
    last[x]=len++;
}
bool spfa()//类比最短路中的 SPFA  
{
    memset(bz,true,sizeof(bz));
    bz[st]=false;// 标志 
    memset(dis,63,sizeof(dis));
    dis[st]=0;// 距离 
    p[st]=INF;// 花费 
    q.push(st);
    while(!q.empty())
    {
        int x=q.front();
        bz[x]=true;
        for(int i=last[x]; i!=-1; i=a[i].next)
        {
            int y=a[i].y;
            if(a[i].c>0&&dis[y]>dis[x]+a[i].d)
            {
                dis[y]=dis[x]+a[i].d;//修改距离 
                pos[y]=x;//记录位置 
                pre[y]=i;//修改前驱 
                p[y]=min(p[x],a[i].c);//求最小花费 
                if(bz[y])
                {
                    q.push(y);
                    bz[y]=false;
                }
            }
        }
        q.pop();
    }
    return dis[ed]<1061109567;
}
int flow()
{
    int ans=0;
    while(spfa())
    {
        ans+=p[ed]*dis[ed];
        for(int i=ed; i!=st; i=pos[i])
        {
            a[pre[i]].c -= p[ed];
            a[pre[i]^1].c += p[ed];
        }
    }
    return ans;
}
int main()
{
    int sum=0;
    scanf("%d",&n);
    st=0;
    ed=n+1;
    for(int i=1; i<=n; i++)
    {
        scanf("%d",&b[i]);
        sum+=b[i];
    }
    sum/=n; // 求均值，根据均值来建图 
    memset(last,-1,sizeof(last));
    for(int i=1; i<=n; i++)
        if(b[i]>sum)
            ins(st,i,b[i]-sum,0),ins(i,st,0,0); // 只能流出，不能流入 
        else
            ins(i,ed,sum-b[i],0),ins(ed,i,0,0); // 只能流入 不能流出 
    for(int i=2; i<=n; i++) // 相邻的两个建边 流量无穷，花费为 1 
    {
        ins(i-1,i,INF,1),ins(i,i-1,0,-1);
        ins(i,i-1,INF,1),ins(i-1,i,0,-1);
    }
    ins(1,n,INF,1),ins(n,1,0,-1); // 特殊处理 1 和 n （ 环形嘛 
    ins(n,1,INF,1),ins(1,n,0,-1); // 同上 
    printf("%d\n",flow());
    return 0;
}