POJ 2175：Evacuation Plan（费用流消圈算法）***

http://poj.org/problem?id=2175

题意：有n个楼，m个防空洞，每个楼有一个坐标和一个人数B，每个防空洞有一个坐标和容纳量C，从楼到防空洞需要的时间是其曼哈顿距离+1，现在给出一个方案，问该方案是否是让所有人到防空洞避难的花费时间最少的方案，如果不是，输出一个最佳方案。

思路：一开始直接用最小费用最大流，超时了。学习了一下消圈算法。

如果不考虑得到最小费用，只需要考虑当前是否最小费用的话，那么是可以用消圈算法来解决的。

结论：当没有负圈的时候，当前的费用是最小的。

因此，构图的时候，根据给出的方案构造出残余网络，然后直接跑一遍SPFA，如果出现负圈，说明当前的答案不是最优的（因为反向边是-cost，可以得到更小的费用，因此是负圈）。

考虑构造新的方案：对于该负圈，记录起路径，然后遍历，因为图存的是正向边的流量，所以如果正向边出现在负圈里，需要加上，代表跑这条边更优,反向边则减去。

学习地址

 #include <cstdio>
 #include <algorithm>
 #include <iostream>
 #include <cstring>
 #include <string>
 #include <cmath>
 #include <queue>
 #include <vector>
 #include <map>
 #include <set>
 #include <stack>
 using namespace std;
 #define INF 0x3f3f3f3f
 #define N 210
 typedef long long LL;
 struct Edge {
     int u, v, nxt, cap, cost;
 } edge[N*N];
 int head[N], tot, pre[N], dis[N], vis[N], inq[N], x[N], y[N], b[N], p[N], q[N], c[N], mp[N][N], S, T;

 void Add(int u, int v, int cap, int now, int cost) {
     edge[tot] = (Edge) { u, v, head[u], cap - now, cost }; head[u] = tot++;
     edge[tot] = (Edge) { v, u, head[v], now, -cost }; head[v] = tot++;
 }

 int cal(int x1, int y1, int x2, int y2) { return abs(x2 - x1) + abs(y2 - y1) + ; }

 int SPFA(int S, int n) {
     queue<int> que;
     que.push(S);
     memset(dis, INF, sizeof(dis));
     memset(vis, , sizeof(vis));
     memset(inq, , sizeof(inq));
     dis[S] = ; vis[S] = ; pre[S] = S;
     while(!que.empty()) {
         int u = que.front(); que.pop();
         vis[u] = ;
         for(int i = head[u]; ~i; i = edge[i].nxt) {
             int v = edge[i].v, cost = edge[i].cost, cap = edge[i].cap;
             if(dis[v] > dis[u] + cost && cap > ) {
                 dis[v] = dis[u] + cost; pre[v] = u;
                 if(!vis[v]) {
                     vis[v] = , que.push(v);
                     if(++inq[v] > n) return v;
                 }
             }
         }
     }
     return ;
 }

 bool inside(int L, int R, int now) { if(L <= now && now <= R) return true; return false; }

 int main() {
     int n, m;
     while(~scanf("%d%d", &n, &m)) {
         S = , T = n + m + ; int res = , ans;
         memset(head, -, sizeof(head)), tot = ;
         memset(dis, , sizeof(dis));
         for(int i = ; i <= n; i++) scanf("%d%d%d", &x[i], &y[i], &b[i]);
         for(int i = ; i <= m; i++) scanf("%d%d%d", &p[i], &q[i], &c[i]);
         for(int i = ; i <= n; i++) for(int j = ; j <= m; j++) {
             scanf("%d", &mp[i][j]);
             int d = cal(x[i], y[i], p[j], q[j]);
             Add(i, j + n, INF, mp[i][j], d);
             res += d * mp[i][j]; dis[j] += mp[i][j];
         }
         for(int i = ; i <= n; i++) Add(S, i, b[i], , );
         for(int i = ; i <= m; i++) Add(i + n, T, c[i], dis[i], );
         ans = SPFA(S, T);
         if(!ans) puts("OPTIMAL");
         else {
             memset(vis, , sizeof(vis));
             while(!vis[ans]) { vis[ans] = ; ans = pre[ans]; }
             int tmp = ans;
             do { // 图存的是正向边的流量,因此如果正向边出现在负圈里,需要加上,代表跑这条边更优,反向边减去
                 if(inside(, n, pre[tmp]) && inside(n + , n + m, tmp)) mp[pre[tmp]][tmp-n]++;
                 if(inside(, n, tmp) && inside(n + , n + m, pre[tmp])) mp[tmp][pre[tmp]-n]--;
                 tmp = pre[tmp];
             } while(tmp != ans);
             puts("SUBOPTIMAL");
             for(int i = ; i <= n; i++) for(int j = ; j <= m; j++)
                 printf("%d%c", mp[i][j], j == m ? '\n' : ' ');
         }
     }
     return ;
 }

 /*
 3 4
 -3 3 5
 -2 -2 6
 2 2 5
 -1 1 3
 1 1 4
 -2 -2 7
 0 -1 3
 3 1 1 0
 0 0 6 0
 0 3 0 2
 */