线性规划与网络流24题 负载平衡问题

题目描述 Description

    G 公司有n 个沿铁路运输线环形排列的仓库，每个仓库存储的货物数量不等。如何用最
    少搬运量可以使n 个仓库的库存数量相同。搬运货物时，只能在相邻的仓库之间搬运。
    «编程任务：
    对于给定的n 个环形排列的仓库的库存量，编程计算使n 个仓库的库存数量相同的最少
    搬运量。

输入描述 Input Description

    第1 行中有1 个正整数n（n<=100），表示有n
    个仓库。第2 行中有n个正整数，表示n个仓库的库存量。

输出描述 Output Description

    将计算出的最少搬运量输出

样例输入 Sample Input

    5
    17 9 14 16 4

样例输出 Sample Output

    11

建图很简单

先计算出平均值，如果多了就从s向它连一条容量为差值费用为0的边，如果少了就向t连一条容量为差值费用为0的边

然后每个点向旁边两个点连一条容量为inf费用为1的边，然后跑最小费用最大流就行了（一开始傻叉的把一个点拆成了两个点）

 

const
    inf=100000;
    maxn=105;
type
    path=record
      next,last,w,c:longint;
    end;
var
    edge:array[0..maxn*8]of path;
    first:array[0..maxn]of longint;
    a:array[0..maxn]of longint;
    n,tot,s,t:longint;

procedure insert(x,y,c,w:longint);
begin
    inc(tot);
    edge[tot].next:=first[x];
    edge[tot].last:=y;
    edge[tot].w:=w;
    edge[tot].c:=c;
    first[x]:=tot;
    inc(tot);
    edge[tot].next:=first[y];
    edge[tot].last:=x;
    edge[tot].w:=-w;
    edge[tot].c:=0;
    first[y]:=tot;
end;

procedure init;
var
    i,sum:longint;
begin
    read(n);
    tot:=1;
    s:=0;
    t:=n+1;
    sum:=0;
    for i:=1 to n do
      begin
        read(a[i]);
        inc(sum,a[i]);
      end;
    sum:=sum div n;
    for i:=1 to n do
      begin
        if a[i]>sum then insert(i,t,a[i]-sum,0);
        if a[i]<sum then insert(s,i,sum-a[i],0);
      end;
    for i:=1 to n do
      begin
        insert(i,i mod n+1,inf,1);
        insert(i mod n+1,i,inf,1);
      end;
end;

var
    flow,time,ans:longint;
    flag,dis,f:array[0..maxn]of longint;

function dfs(x,flow:longint):longint;
var
    i,d,min:longint;
begin
    if x=t then
    begin
      inc(ans,flow*dis[t]);
      exit(flow);
    end;
    flag[x]:=time;
    i:=first[x];
    dfs:=0;
    while i<>0 do
      begin
        d:=dis[x]+edge[i].w-dis[edge[i].last];
        min:=flow;
        if min>edge[i].c then min:=edge[i].c;
        if (min>0) and (d<f[edge[i].last]) then f[edge[i].last]:=d;
        if (min>0) and (d=0) and (flag[edge[i].last]<>time) then
        begin
          d:=dfs(edge[i].last,min);
          inc(dfs,d);
          dec(flow,d);
          inc(edge[i xor 1].c,d);
          dec(edge[i].c,d);
        end;
        if flow=0 then break;
        i:=edge[i].next;
      end;
end;

procedure work;
var
    i,del:longint;
begin
    repeat
      inc(time);
      for i:=1 to t do
        f[i]:=inf;
      inc(flow,dfs(s,inf));
      del:=inf;
      for i:=1 to t do
        if (flag[i]<>time) and (del>f[i]) then del:=f[i];
      if del=inf then break;
      for i:=1 to t do
        if flag[i]<>time then inc(dis[i],del);
    until false;
    write(ans);
end;

begin
    init;
    work;
end.