[POJ 2516]Minimum Cost[費用流][建圖]

題意分析：

N個店主，M個供貨商，K種貨物，每個店主都有自己需要的貨物數量，每個供貨商都會提供一定數量的貨物，每個供貨商給店主提供不同貨物的單位價格不同，現在問題來了：供貨商如何花費最少的費用給店主提供上貨物呢？最少費用是多少？無法滿足要求則輸出-1。

解題思路：

這題如果將店主的需要貨物拆點，供貨商的提供貨物拆點，再來個超級源匯點，邊的個數多的嚇人。。。。。

發現可以一種貨物計算一次費用，返回的最大流就是這種貨物能夠提供的最大總數，如果這個最大流<店主需要的量，那麼就是-1了。

於是我們一種貨物建一次圖，源點到供貨商連一條邊，容量爲供貨量，費用爲0，匯點和店主連一條邊，容量爲需求量，費用爲0，供貨商和店主連邊，容量爲INF，費用爲當前矩陣對應的費用。此題得解。

個人感受：

個人思路一直是第一行的解題思路。。。。。各種拆點。。。。。這回知道連圖都能拆了。。。。

具體代碼如下：

#include<algorithm>
#include<cctype>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iomanip>
#include<iostream>
#include<map>
#include<queue>
#include<set>
#include<sstream>
#include<stack>
#include<string>
#define ll long long
#define pr(x) cout << #x << " = " << (x) << '\n';
using namespace std;

const int MAXN = 200;
const int MAXM = 2e4;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int to,next,cap,flow,cost;
}edge[MAXM];
int head[MAXN], tol, nk[60][60], mk[60][60], need[60], have[60];
int pre[MAXN],dis[MAXN];
bool vis[MAXN];
int N;//節點總個數，節點編號從0~N-1
void init(int n)
{
    N = n;
    tol = 0;
    memset(need, 0, sizeof need);
    memset(have, 0, sizeof have);
}
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;
    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 main()
{
    int n, m, k;
    while (~scanf("%d%d%d", &n, &m, &k) && (n|m|k)) {
        init(n + m + 2);
        int s = 0, t = n + m + 1;
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= k; ++j)
                scanf("%d", &nk[i][j]), need[j] += nk[i][j];
        }
        for (int i = 1; i <= m; ++i) {
            for (int j = 1; j <= k; ++j)
                scanf("%d", &mk[i][j]), have[j] += mk[i][j];
        }

        bool flag = 0;
        int x = 0, ans = 0;
        for (int l = 1; l <= k; ++l) {
            tol = 0;
            memset(head, -1, sizeof head);
            for (int i = 1; i <= n; ++i) {
                for (int j = 1; j <= m; ++j) {
                    scanf("%d", &x);
                    addedge(n + j, i, mk[j][l], x);
                }
            }

            for (int i = 1; i <= n; ++i) addedge(i, t, nk[i][l], 0);
            for (int i = 1; i <= m; ++i) addedge(s, i + n, mk[i][l], 0);

            int flow = minCostMaxflow(s, t, ans);
            if (flow < need[l]) flag = 1;
        }

        if (flag) printf("-1\n");
        else printf("%d\n", ans);
    }
    return 0;
}