POJ 2516：Minimum Cost（最小费用流）

https://vjudge.net/problem/11079/origin

题意：有N个商店和M个供应商和K种物品，每个商店每种物品有一个需求数，每个供应商每种物品有一个供应量，供应商到商店之间的运输需要花费，如果供不应求输出-1，否则输出最小花费。

思路：比较明显的最小费用流。想法大概都是源点和供应商连一条容量为供应量，花费为0的边，商店和汇点之间连一条容量为需求量，花费为0的边，供应商和商店之间连一条容量为INF，花费为题意给出的花费的边。建图的话一开始是直接对于每一个商店每一种物品和每一个供应商每一种物品都看做一个点，这样的点数是n*k+m*k+两个源点，超级大的图，就TLE了。看了下别人的思路，每一种商品是独立的，那么对于每一种商品建一次图，这样的点数是n + m + 两个源点，然后跑 k 次。优化了N多。。。。太菜鸡了。。。。还有数组开的不能太小，开55的时候TLE，105就AC了。

 #include <cstdio>
 #include <algorithm>
 #include <iostream>
 #include <cstring>
 #include <string>
 #include <cmath>
 #include <queue>
 #include <vector>
 #include <map>
 #include <set>
 using namespace std;
 #define INF 0x3f3f3f3f
 #define N 105
 typedef long long LL;
 struct Edge {
     int u, v, cap, cost;
     Edge () {}
     Edge (int u, int v, int cap, int cost) : u(u), v(v), cap(cap), cost(cost) {}
 } edge[N*N];
 int tot, pre[N], vis[N], dis[N], S, T;
 int shop[N][N], sup[N][N], tolshop[N], tolsup[N], cost[N][N][N];
 vector<int> G[N];
 void Add(int u, int v, int cap, int cost) {
     edge[tot] = Edge(u, v, cap, cost);
     G[u].push_back(tot++);
     edge[tot] = Edge(v, u, , -cost);
     G[v].push_back(tot++);
 }

 int SPFA() {
     queue<int> que;
 //    puts("SPFA");
     memset(dis, INF, sizeof(dis));
     memset(vis, , sizeof(vis));
     dis[S] = ; que.push(S);
     vis[S] = ;
     while(!que.empty()) {
         int u = que.front(); que.pop();
         vis[u] = ;
         for(int i = ; i < G[u].size(); i++) {
             Edge& e = edge[G[u][i]];
             if(dis[u] + e.cost < dis[e.v] && e.cap > ) { // 先松弛在判断是否在队里
                 dis[e.v] = dis[u] + e.cost;
                 pre[e.v] = G[u][i];
                 if(vis[e.v]) continue;
                 que.push(e.v);
                 vis[e.v] = ;
             }
         }
     }
     return dis[T] < INF;
 }

 void MFMC(int &maxflow, int &cost) {
     int u = T, flow = INF;
     while(u != S) {
         Edge& e = edge[pre[u]];
         if(e.cap < flow) flow = e.cap;
         u = e.u;
     } u = T;
     while(u != S) {
         Edge& e1 = edge[pre[u]];
         Edge& e2 = edge[pre[u]^];
         e1.cap -= flow; e2.cap += flow;
         cost += flow * e1.cost;
         u = e1.u;
     }
     maxflow += flow;
 }

 int main() {
     int n, m, k;
     while(~scanf("%d%d%d", &n, &m, &k), n + m + k) {
         S = ; T = n + m + ;
         memset(tolsup, , sizeof(tolsup));
         memset(tolshop, , sizeof(tolshop));
         for(int i = ; i <= n; i++) {
             for(int j = ; j <= k; j++) {
                 scanf("%d", &shop[i][j]);
                 tolshop[j] += shop[i][j];
             }
         }
         for(int i = ; i <= m; i++) {
             for(int j = ; j <= k; j++) {
                 scanf("%d", &sup[i][j]);
                 tolsup[j] += sup[i][j];
             }
         }
         for(int x = ; x <= k; x++) {
             for(int i = ; i <= n; i++) {
                 for(int j = ; j <= m; j++) {
                     scanf("%d", &cost[x][i][j]);
                 }
             }
         }
         int flag = ;
         int maxflow = , mincost = ;
         for(int x = ; x <= k; x++) {
             if(tolshop[x] > tolsup[x]) {
                 flag = ; break;
             }
             tot = ;
             for(int i = S; i <= T; i++) G[i].clear();
             for(int i = ; i <= n; i++) {
                 Add(i, T, shop[i][x], );
             }
             for(int i = ; i <= m; i++) {
                 Add(S, i + n, sup[i][x], );
             }
             for(int i = ; i <= n; i++) {
                 for(int j = ; j <= m; j++) {
                     Add(j + n, i, sup[j][x], cost[x][i][j]);
                 }
             }
             while(SPFA()) MFMC(maxflow, mincost);
         }
         if(flag) printf("%d\n", mincost);
         else puts("-1");
     }
     return ;
 }