POJ 2510 Minimum Cost （最小费用最大流）

题意：有 n 个商店，k种物品和 m 个供货商，让你求进满足商店需求的货物的最小花费。

首先n, m, k
然后是一个n * k的矩阵，n个商店对每种货物的需求，表示第 i 个商店需要第 j 种货物 x个
然后是m * k 的矩阵，m个供货商可以供k种货物的数量，表示第 i 个供货商提供第 j 种货物 x 个
接下来是 k 个 n * m 的矩阵，表示第 i 个货物，由 p 供应商发货给 j 商店的价格x

题解：最小费用最大流
如果按照源点->商店->物品->供应商->汇点建图，会超时，所以对每一个物品分别建图跑最大流。
对每个商品，按照源点->商店->供应商->汇点建图：
源点 到 商店：容量为商店当前商品需求之和，费用为0。
商店 到 供应商：容量为INF（保证商店都能到每一个供应商，即先考虑最大流），费用为矩阵对应费用。
供应商 到 汇点：容量为供应商当前商品所有数量（限制商店），费用为0。

wa的看一下下面这组数据：

2 2 1
1
1
1
1
1 2
2 100
ans：4

这里用的spfa。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#include<cmath>
#include<vector>
#include<fstream>
#include<set>
#include<map>
#include<sstream>
#include<iomanip>
#define ll long long
using namespace std;
//最小费用最大流，求最大费用只需要取相反数，结果取相反数即可。
//点的总数为 N，点的编号 0 ∼ N-1 记得初始化
const int MAXN = 10000;
const int MAXM = 100000;
const int INF = 0x3f3f3f3f;
struct Edge {
    int to, next, cap, flow, cost;
}edge[MAXM];
int head[MAXN], tol;
int pre[MAXN], dis[MAXN];
bool vis[MAXN];
int N;//节点总个数，节点编号从 0∼N-1
void init(int n) {
    N = n;
    tol = 0;
    memset(head, -1, sizeof(head));
}
void addedge(int u, int v, int cap, int cost) {
    edge[tol].to = v;
    edge[tol].cap = cap;
    edge[tol].cost = cost;
    edge[tol].flow = 0;
    edge[tol].next = head[u];
    head[u] = tol++;
    edge[tol].to = u;
    edge[tol].cap = 0;
    edge[tol].cost = -cost;
    edge[tol].flow = 0;
    edge[tol].next = head[v];
    head[v] = tol++;
}
bool spfa(int s, int t) {
    queue<int>q;
    for (int i = 0; i < N; i++) {
        dis[i] = INF;
        vis[i] = false;
        pre[i] = -1;
    }
    dis[s] = 0;
    vis[s] = true;
    q.push(s);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        vis[u] = false;
        for (int i = head[u]; i != -1; i = edge[i].next) {
            int v = edge[i].to;
            if (edge[i].cap > edge[i].flow && dis[v] > dis[u] + edge[i].cost)
            {
                dis[v] = dis[u] + edge[i].cost;
                pre[v] = i;
                if (!vis[v]) {
                    vis[v] = true;
                    q.push(v);
                }
            }
        }
    }
    if (pre[t] == -1)return false;
    else return true;
}
//返回的是最大流， cost 存的是最小费用
int minCostMaxflow(int s, int t, int& cost) {
    int flow = 0;
    cost = 0;
    while (spfa(s, t)) {
        int Min = INF;
        for (int i = pre[t]; i != -1; i = pre[edge[i ^ 1].to]) {
            if (Min > edge[i].cap - edge[i].flow)
                Min = edge[i].cap - edge[i].flow;
        }
        for (int i = pre[t]; i != -1; i = pre[edge[i ^ 1].to]) {
            edge[i].flow += Min;
            edge[i ^ 1].flow -= Min;
            cost += edge[i].cost * Min;
        }
        flow += Min;
    }
    return flow;
}
int n, m, k, order[55][55], sup[55][55], co, needk[55];
int main() {
	while (~scanf("%d%d%d", &n, &m, &k) && n) {
        memset(needk, 0, sizeof(needk));
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= k; j++) {
				scanf("%d", &order[i][j]);
                needk[j] += order[i][j];
			}
		}
		for (int i = 1; i <= m; i++) {
			for (int j = 1; j <= k; j++) {
				scanf("%d", &sup[i][j]);
			}
		}
        int flag = 1, ans = 0;
		for (int i = 1; i <= k; i++) {
            init(n + m + 2);
            for (int j = 1; j <= n; j++) addedge(0, j, order[j][i], 0);
            for (int j = 1; j <= m; j++) addedge(j + n, n + m + 1, sup[j][i], 0);
            for (int j = 1; j <= n; j++) {
                for (int p = 1; p <= m; p++) {
                    scanf("%d", &co);
                    addedge(j, p + n, INF, co);
                }
            }
            if (minCostMaxflow(0, n + m + 1, co) < needk[i]) flag = 0;
            else ans += co;
		}
        printf("%d\n", flag ? ans : -1);
	}
	return 0;
}