洛谷 P3381 【模板】最小费用最大流

最新推荐文章于 2024-08-03 15:53:55 发布

原创最新推荐文章于 2024-08-03 15:53:55 发布 · 220 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#洛谷 #P3381 #最小费用最大流

网络流同时被 3 个专栏收录

7 篇文章

订阅专栏

最大流

7 篇文章

订阅专栏

费用流

2 篇文章

订阅专栏

本文详细介绍了一种解决网络流问题的重要算法——最小费用最大流(MCMF)。该算法利用了反向边的概念，通过调整节点间的相对距离来消除负权边，确保能够运用Dijkstra算法找到最短路径。文章提供了完整的C++代码实现，并解释了如何逐步求解最短路径并更新最大流直至最优解。

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

题目链接

MCMF(最小费用最大流)：由于要使用反向边。定义一个h[i]：表示从汇点到i的最短距离。对于一条边e(v,u)，e.cost = e.cost + h[v] - h[u]，这样可以保证图中没有负权边的存在，这样就可以使用dij来求最短路。

每次求一条最短路，然后通过这条最短路更新最大流，直到找不出最短路为止。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<string>
#include<map>
#include<vector>
#include<queue>
using namespace std;
#define ll long long
#define PI acos(-1)
#define INF 0x3f3f3f3f
#define NUM 50010
#define debug true
#define lowbit(x) ((-x)&x)
#define ffor(i,d,u) for(int i=d;i<=u;++i)
#define _ffor(i,u,d) for(int i=u;i>=d;--i)
#define mst(array,Num) memset(array,Num,sizeof(array))
const int p = 1e9+7;
int n,m,ednum;
int head[NUM/10],h[NUM/10]={};
int pre[NUM/10],dist[NUM/10];
struct edge
{
    int next,to,w,c;
}e[NUM<<1];
struct Vertex
{
    int id,dis;
    bool operator>(const Vertex &x)const
    {
        return dis > x.dis ;
    }
};
template <typename T>
inline void read(T &x){
    char ch = getchar();x = 0;
    for (; ch < '0' || ch > '9'; ch = getchar());
    for (; ch >='0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
}
template <typename T>
inline void write(T x)
{
    int len=0;char c[21];
    if(x<0)putchar('-'),x*=(-1);
    do{++len;c[len]=(x%10)+'0';}while(x/=10);
    _ffor(i,len,1)putchar(c[i]);
}
inline bool Dij(const int &s,const int &t)
{
    Vertex x,y;
    priority_queue < Vertex , vector < Vertex > , greater < Vertex > > q;
    mst(dist,INF);
    x.id = s,dist[s] = x.dis = 0;
    pre[s] = -1;
    q.push(x);
    while(!q.empty())
    {
        x = q.top(),q.pop();
        if(x.dis > dist[x.id])continue;
        for(int i = head[x.id] ; i != -1 ; i = e[i].next)
        {
            y.id = e[i].to;
            if(e[i].w > 0 && dist[y.id] > dist[x.id]+e[i].c+h[x.id]-h[y.id])
            {
                y.dis = dist[y.id] = dist[x.id]+e[i].c+h[x.id]-h[y.id];
                pre[y.id] = i;
                q.push(y);
            }
        }
    }
    if(dist[t] == INF)return false;
    return true;
}
inline void MinCost_MaxFlow(const int &s,const int &t,int &cost,int &maxflow)
{
    int d=INF;
    mst(h,0);
    while(d > 0&&Dij(s,t))
    {
        ffor(i,1,n) h[i] += dist[i];
        d = INF;
        for(int i = pre[t] ; i != -1 ; i = pre[e[i^1].to])
            d = min(d , e[i].w);
        maxflow += d , cost += h[t] * d;
        for(int i = pre[t] ; i != -1 ; i = pre[e[i^1].to])
        {
            e[i].w -= d;
            e[i^1].w += d;
        }
    }
}
inline void AC()
{
    int x,y,wei,s,t;
    int cost,maxflow=0;
    read(n),read(m),read(s),read(t);
    maxflow = 0,ednum = -1,mst(head,-1);
    ffor(i,1,m)
    {
        read(x),read(y),read(wei),read(cost);
        e[++ednum].to = y,e[ednum].w = wei,e[ednum].next = head[x],head[x] = ednum,e[ednum].c = cost;
        e[++ednum].to = x,e[ednum].w = 0,e[ednum].next = head[y],head[y] = ednum,e[ednum].c = -cost;
    }
    cost = 0;
    MinCost_MaxFlow(s,t,cost,maxflow);
    write(maxflow),putchar(' '),write(cost),puts("");
}
int main()
{
    AC();
    return 0;
}