[codeVS1916] 负载平衡问题（最小费用流，拆点）

题目链接：http://codevs.cn/problem/1916/

n个点之间可以相互传递值，每传递一次步骤+1。最终希望所有点的值相同，问最少步骤。

最终所有值应当是平均数avg，如何在两个相邻点之间传输值？可以先拆点，再建边：

将每一个点拆成两个点（两个点集分别记为①和②），同点②到①之间的容量为inf，费用为0。

拆完点后，按照要求每一个①点连向相邻两个点的②点，容量为inf，费用为1。

需要注意的是，保证移动完每一步可以判断是否能直接流向汇点，所以要在①点集合中向汇点建边，容量为avg，费用为0。

这里建图建挫了，大致是这样：



跑最小费用流就可以了。

PS:这么看来BNU校赛的A题也可以这么建模（虽然贪心过的）。

附链接，可以思考：https://www.bnuoj.com/v3/contest_show.php?cid=9056#problem/A

1 #include <bits/stdc++.h>
2 using namespace std;
3
4 typedef long long LL;
5 typedef struct Node {
6     int u, v, next;
7     LL c, w;
8 }Node;
9 const int maxn = 210;
10 const int maxm = 4010;
11 const LL mod = 0x3f3f3f3fLL;
12 const LL inf = (1LL<<55);
13 int tot, head[maxn];
14 LL dist[maxn];
15 LL cost, flow;
16 Node e[maxm];
17 int pre[maxn];
18 bool visit[maxn];
19 queue<int> Q;
20 int S, T, N;
21
22 void adde(int u, int v, LL c, LL w) {
23     e[tot].u = u; e[tot].v = v; e[tot].c = c; e[tot].w = w; e[tot].next = head[u]; head[u] = tot++;
24     e[tot].u = v; e[tot].v = u; e[tot].c = 0; e[tot].w = -w; e[tot].next = head[v]; head[v] = tot++;
25 }
26 bool spfa(int s, int t, int n) {
27     int i;
28     for(i = 0; i <= n; i++) {
29         dist[i] = inf;
30         visit[i] = 0;
31         pre[i] = -1;
32     }
33     while(!Q.empty()) Q.pop();
34     Q.push(s);
35     visit[s] = true;
36     dist[s] = 0;
37     pre[s] = -1;
38     while(!Q.empty()) {
39         int u = Q.front();
40         visit[u] = false;
41         Q.pop();
42         for(int j = head[u]; j != -1; j = e[j].next) {
43             if(e[j].c > 0 && dist[u] + e[j].w < dist[e[j].v]) {
44                 dist[e[j].v] = dist[u] + e[j].w;
45                 pre[e[j].v] = j;
46                 if(!visit[e[j].v]) {
47                     Q.push(e[j].v);
48                     visit[e[j].v] = true;
49                 }
50             }
51         }
52     }
53     if(dist[t] == inf) return false;
54     else return true;
55 }
56 LL ChangeFlow(int t) {
57     LL det = mod;
58     int u = t;
59     while(~pre[u]) {
60         u = pre[u];
61         det = min(det, e[u].c);
62         u = e[u].u;
63     }
64     u = t;
65     while(~pre[u]) {
66         u = pre[u];
67         e[u].c -= det;
68         e[u ^ 1].c += det;
69         u = e[u].u;
70     }
71     return det;
72 }
73 LL MinCostFlow(int s, int t, int n) {
74     LL mincost, maxflow;
75     mincost = maxflow = 0;
76     while(spfa(s, t, n)) {
77         LL det = ChangeFlow(t);
78         mincost += det * dist[t];
79         maxflow += det;
80     }
81     cost = mincost;
82     flow = maxflow;
83     return mincost;
84 }
85
86 int n;
87 int a[maxn];
88
89 int main() {
90     LL avg = 0;
91     scanf("%d", &n);
92     for(int i = 1; i <= n; i++) {
93         scanf("%d", &a[i]);
94         avg += a[i];
95     }
96     avg /= n;
97     tot = 0;
98     memset(head, -1, sizeof(head));
99     S = 0, T = 2 * n + 1; N = T + 1;
100     for(int i = 1; i <= n; i++) {
101         adde(0, i, a[i], 0);
102         adde(i+n, i, inf, 0);
103         adde(i, T, (LL)avg, 0);
104     }
105     for(int i = 1; i < n; i++) adde(i, i+n+1, inf, 1);
106     adde(n, n+1, inf, 1);
107     for(int i = 2; i <= n; i++) adde(i, i+n-1, inf, 1);
108     adde(1, 2*n, inf, 1);
109     cout << MinCostFlow(S, T, N) << endl;
110     return 0;
111 }