【最小费用流】POJ - 2516 Minimum Cost

Problem Description

本人英语 语文都有点差，参考了这篇大佬博客才知道题目什么意思和样例什么意思http://blog.csdn.net/lyy289065406/article/details/6742534

思路：

我是求每个物品的最小费，然后相加。我觉得核心就是看懂样例，图还是很好建的。店铺拆点限流，流量为店铺的需求量，费用0。供应商拆点限流，流量提供的量，费用0。超级源点到供应商建边，流量无穷，费用0。供应商到店铺流量比提供的量大就可以，费用根据题目所给。店铺到超级汇点建边，流量无穷，费用0。然后求物品次最小费求和就可以了。判断能不能满足店铺需求就是判断店铺之间的流量是不是为0就可以了。

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
struct node
{
    int u, to, w, c, next;//当前点，目的点，流量，费用，另一个目的点对应Map[]下标
};
#define inf 0x3f3f3f3f
node Map[50000];
int head[500], vis[500], dist[500], pre[500], cnt;
int need[100][100], offer[100][100];
void add(int u, int v, int w, int c)//前向星存图
{
    Map[cnt].u = u;
    Map[cnt].to = v;
    Map[cnt].w = w;//正向为w
    Map[cnt].c = c;//正向为+
    Map[cnt].next = head[u];
    head[u] = cnt++;
    Map[cnt].u = v;
    Map[cnt].to = u;
    Map[cnt].w = 0;//反向为0
    Map[cnt].c = -c;//反向为-
    Map[cnt].next = head[v];
    head[v] = cnt++;
}
int spfa(int s, int e)//求最短路，记录路径
{
    memset(dist, inf, sizeof(dist));
    memset(vis, 0, sizeof(vis));
    memset(pre, -1, sizeof(pre));
    queue<int> q;
    q.push(s);
    dist[s] = 0;
    while(!q.empty())
    {
        s = q.front(); q.pop();
        vis[s] = 0;
        for(int i = head[s]; ~i; i = Map[i].next)
        {
            int to = Map[i].to, w = Map[i].w, c = Map[i].c;
            if(dist[to] > dist[s] + c && w)
            {
                dist[to] = dist[s] + c;
                pre[to] = i;
                if(!vis[to])
                {
                    vis[to] = 1;
                    q.push(to);
                }
            }
        }
    }
    if(pre[e] != -1) return 1;
    else return 0;
}
int Min_cost(int s, int e)
{
    int ans = 0;
    while(spfa(s, e))//能找到最短路，也就是增广路
    {
        int max_flow = inf;
        int u = pre[e];
        while(u != -1)
        {
            max_flow = min(max_flow, Map[u].w);//这条增广路，限制流量
            u = pre[Map[u].u];
        }
        u = pre[e];
        while(u != -1)//更新边，和最小费用
        {
            Map[u].w -= max_flow;
            Map[u^1].w += max_flow;
            ans += max_flow * Map[u].c;
            u = pre[Map[u].u];
        }
    }
    return ans;
}
int main()
{
    int n, m, k, i, j, k1;
    while(~scanf("%d %d %d", &n, &m, &k))
    {
        if(!n && !m && !k) break;
        for(i = 1; i <= n; i++)
        {
            for(j = 1; j <= k; j++)
            {
                scanf("%d", &need[i][j]);//店主i对j物品的需求
            }
        }
        for(i = 1; i <= m; i++)
        {
            for(j = 1; j <= k; j++)
            {
                scanf("%d", &offer[i][j]);//供应商i对j这个物品供应量
            }
        }
        int cost;
        int ans = 0;
        int flag = 1;
        for(k1 = 1; k1 <= k; k1++)
        {
            memset(head, -1, sizeof(head));
            cnt = 0;
            for(i = 1; i <= n; i++)
            {
                add(i, i+n, need[i][k1], 0);//店铺到店铺
                add(i+n, 0, inf, 0);//店铺到超级汇点
                for(j = 1; j <= m; j++)
                {
                    //第j个供应商运送第k1个物品到第i个店主的费用
                    scanf("%d", &cost);
                    add(j+2*n, i, offer[j][k1], cost);//供应商到店铺
                    if(i == 1)
                    {
                        add(m+2*n+j, j+2*n, offer[j][k1], 0);//供应商到供应商
                        add(2*m+2*n+1, j+2*n+m, inf, 0);//超级源点到供应商
                    }
                }
            }
            if(flag)
            ans += Min_cost(2*m+2*n+1, 0);//求和
            for(i = 1; i <= n && flag; i++)//判断是否满足需求
            {
                for(j = head[i]; ~j; j = Map[j].next)
                {
                    int to = Map[j].to, w = Map[j].w;
                    if(to == i+n)
                    {
                        if(w) {
                            flag = 0;
                            break;
                        }
                    }
                }
            }
        }
        if(flag)
        printf("%d\n", ans);
        else printf("-1\n");
    }
}