HDU 6118 度度熊的交易计划最小费用可行流

最新推荐文章于 2021-02-02 23:55:16 发布

霜刃未曾试

最新推荐文章于 2021-02-02 23:55:16 发布

阅读量417

点赞数

CC 4.0 BY-SA版权

分类专栏：最小费用流

本文链接：https://blog.youkuaiyun.com/discreeter/article/details/77162160

最小费用流专栏收录该内容

14 篇文章

订阅专栏

本文介绍了一个基于费用流算法的经典问题，通过解决一个关于商品生产和销售的优化问题来讲解如何构建和求解费用流网络。文章提供了完整的代码示例，并解释了如何通过调整费用和流量来获取最大利润。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：

http://acm.hdu.edu.cn/showproblem.php?pid=6118

题意：

Problem Description
度度熊参与了喵哈哈村的商业大会，但是这次商业大会遇到了一个难题：

喵哈哈村以及周围的村庄可以看做是一共由n个片区，m条公路组成的地区。

由于生产能力的区别，第i个片区能够花费a[i]元生产1个商品，但是最多生产b[i]个。

同样的，由于每个片区的购买能力的区别，第i个片区也能够以c[i]的价格出售最多d[i]个物品。

由于这些因素，度度熊觉得只有合理的调动物品，才能获得最大的利益。

据测算，每一个商品运输1公里，将会花费1元。

那么喵哈哈村最多能够实现多少盈利呢？

Input
本题包含若干组测试数据。
每组测试数据包含：
第一行两个整数n,m表示喵哈哈村由n个片区、m条街道。
接下来n行，每行四个整数a[i],b[i],c[i],d[i]表示的第i个地区，能够以a[i]的价格生产，最多生产b[i]个，以c[i]的价格出售，最多出售d[i]个。
接下来m行，每行三个整数,u[i],v[i],k[i]，表示该条公路连接u[i],v[i]两个片区，距离为k[i]

可能存在重边，也可能存在自环。

满足:
1<=n<=500,
1<=m<=1000,
1<=a[i],b[i],c[i],d[i],k[i]<=1000,
1<=u[i],v[i]<=n

思路：

一眼看上去就长的像个费用流。此题求得是最大费用，那么我们将真正的费用取反去求最小，然后再取反就是最大费用了。建图时，从源点向每个点连边，费用为 $a[i]$ ，流量为 $b[i]$ ，从每个点向汇点连边，费用为 $-c[i]$ ，流量为 $d[i]$ ，对于每条公路，在公路连接的两个片区间连边，费用为 $k[i]$ 。建完后跑一个最小费用可行流即可，重边和自环不会影响费用流的正确答案

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
const int N = 500 + 10, INF = 0x3f3f3f3f;
struct edge
{
    int to, cap, cost, next;
} g[N*N*10];

int cnt, head[N];
int dis[N], pre[N];
bool vis[N];

void add_edge(int v, int u, int cap, int cost)
{
    g[cnt].to = u, g[cnt].cap = cap, g[cnt].cost = cost, g[cnt].next = head[v], head[v] = cnt++;
    g[cnt].to = v, g[cnt].cap = 0, g[cnt].cost = -cost, g[cnt].next = head[u], head[u] = cnt++;
}
void spfa(int s, int t)
{
    memset(dis, 0x3f, sizeof dis);
    memset(vis, 0, sizeof vis);
    memset(pre, -1, sizeof pre);
    queue<int> que;
    que.push(s);
    dis[s] = 0, vis[s] = true;
    while(! que.empty())
    {
        int v = que.front(); que.pop();
        vis[v] = false;
        for(int i = head[v]; i != -1; i = g[i].next)
        {
            int u = g[i].to;
            if(g[i].cap > 0 && dis[u] > dis[v] + g[i].cost)
            {
                dis[u] = dis[v] + g[i].cost;
                pre[u] = i;
                if(! vis[u]) que.push(u), vis[u] = true;
            }
        }
    }
}
int cost_flow(int s, int t)
{
    int res = 0, flow = 0;
    while(true)
    {
        spfa(s, t);
        if(dis[t] > 0) return res;//当大于0时，意味着取反后是负的，也就是赔钱，所以不用再求了
        int d = INF;
        for(int i = pre[t]; i != -1; i = pre[g[i^1].to])
            d = min(d, g[i].cap);
        for(int i = pre[t]; i != -1; i = pre[g[i^1].to])
            g[i].cap -= d, g[i^1].cap += d;
        flow += d;
        res += d * dis[t];
    }
}
int main()
{
    int n, m;
    while(~ scanf("%d%d", &n, &m))
    {
        cnt = 0;
        memset(head, -1, sizeof head);
        int ss = 0, tt = n + 1;
        for(int i = 1; i <= n; i++)
        {
            int a, b, c, d;
            scanf("%d%d%d%d", &a, &b, &c, &d);
            add_edge(ss, i, b, a);
            add_edge(i, tt, d, -c);
        }
        for(int i = 1; i <= m; i++)
        {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            //if(a == b) continue;
            add_edge(a, b, INF, c);
            add_edge(b, a, INF, c);
        }
        printf("%d\n", -cost_flow(ss, tt));
    }
    return 0;
}