最小费用最大流模板

本文介绍了最小费用最大流问题的解决策略,重点在于寻找单位费用最小的增广路。通过SPFA算法来处理可能存在的负权边,将成本视为路径长度。在找到最大流的同时,确保了费用的最小化。当流量达到要求时,即可得出最小费用可行流的解决方案。

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

#include<bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f

typedef long long LL;

const int M=2010;//边数注意啦,我们这东西是有逆向边的,所以边数要×2哦
const int N=510;//点数

struct edge
{
    int to;
    int next;
    int cap;
    int cost;
} e[11000];

int head[N],tot;
int d[N], pre[N], path[N];//pre是用来记录路径的,表示这个点的上一个点是谁,path是用来记录路径所对应的边数
bool vis[N];

void init()
{
    memset(head,-1,sizeof(head));
    tot = 0;
}

void addedge(int s, int t, int cap, int cost)
{
    e[tot].to=t;
    e[tot].cap=cap;
    e[tot].cost=cost;
    e[tot].next=head[s];
    head[s] = tot++;
    e[tot].to=s;
    e[tot].cap=0;
    e[tot].cost=-cost;
    e[tot].next=head[t];
    head[t] = tot++;
}

int spfa(int s, int t)
{
    memset(d,INF,sizeof(d));
    memset(pre,-1,sizeof(pre));
    memset(path,-1,sizeof(path));
    memset(vis,false,sizeof(vis));
    d[s] = 0;
    vis[s] = true;
    queue<int>q;
    q.push(s);
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        vis[u] = false;
        for (int i = head[u]; i!=-1; i = e[i].next)
        {
            int v = e[i].to;
            if (d[v] > d[u] + e[i].cost && e[i].cap > 0)
            {
                d[v] = d[u] + e[i].cost;
                pre[v] = u;
                path[v] = i;
                if (!vis[v])
                {
                    vis[v] = true;
                    q.push(v);
                }
            }
        }
    }
    return d[t] != INF;
}

int MinCostMaxFlow(int s, int t,int &cost)
{
    int flow;
    flow=cost=0;
    while (spfa(s, t))//找增广路直到找不到为止
    {
        int minn = INF;
        for (int i = t; i != s && ~i; i = pre[i])
            minn = min(minn, e[path[i]].cap);
        for (int i = t; i != s && ~i; i = pre[i])
        {
            e[path[i]].cap -= minn;
            e[path[i] ^ 1].cap += minn;
        }
        flow += minn;
        cost += minn * d[t];
    }
    return flow;
}

int main()
{
    int n,m;
    while(~scanf("%d %d",&n,&m))
    {
        init();
        for (int k=1;k<=n;k++)
        {
            int a,b,c,d;
            scanf("%d %d %d %d",&a,&b,&c,&d);
            addedge(0,k,b,a);
            addedge(k,n+1,d,-c);
        }
        for (int k=1;k<=m;k++)
        {
            int st,en,dis;
            scanf("%d %d %d",&st,&en,&dis);
            addedge(st,en,INF,dis);
            addedge(en,st,INF,dis);
        }

        int cost(0);
        MinCostMaxFlow(0,n+1,cost);
        printf("%d\n",-cost);
    }
}


这个的思路也是找增广路,但是有所不同,我每次找的增广路都是单位费用最小的增广路,这样我们找到最大流之后,找到的就是最小费用最大流

其实这个可以干很多事情,也可以求最小费用可行流,这个在求的时候,找到的流量够了退出循环即可。

那如何求最小费用的增广路呢?

我们使用的是spfa(可能有负边嘛)

把cost当成路径长度就好啦

d【i】就表示从起点到i一个单位的流要的花费


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值