洛谷p3381 最小费用最大流模板题 spfa+ek

题目描述

如题，给出一个网络图，以及其源点和汇点，每条边已知其最大流量和单位流量费用，求出其网络最大流和在最大流情况下的最小费用。

输入格式

第一行包含四个正整数N、M、S、T，分别表示点的个数、有向边的个数、源点序号、汇点序号。

接下来M行每行包含四个正整数ui、vi、wi、fi，表示第i条有向边从ui出发，到达vi，边权为wi（即该边最大流量为wi），单位流量的费用为fi。

输出格式

一行，包含两个整数，依次为最大流量和在最大流量情况下的最小费用。

输入输出样例

输入 #1复制

4 5 4 3
4 2 30 2
4 3 20 3
2 3 20 1
2 1 30 9
1 3 40 5

输出 #1复制

50 280

说明/提示

时空限制：1000ms,128M

（BYX：最后两个点改成了1200ms）

数据规模：

对于30%的数据：N<=10，M<=10

对于70%的数据：N<=1000，M<=1000

对于100%的数据：N<=5000，M<=50000

参考博客：https://blog.youkuaiyun.com/qq_40772692/article/details/83041282

普通的ek算法是在bfs的时候通过反向建边提供后悔机会来寻找增广路，spfa其实与bfs过程有点类似，每次通过spfa找一条费用最小的增广路，直到没有增广路，算法就结束了，因为只要还有增广路，就会增广（最大流一定可以满足），这样我们就只需要每一次都通过spfa去找残余网络的

起点到终点的最小费用就好了

ac代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<queue>
#include<cmath>
#include<string>
#include<set>
#include<map>
using namespace std;
#define LL long long
const int MOD=1e9+7;
const int inf=0x3f3f3f3f;
const LL inff=0x3f3f3f3f3f3f3f3f;
const LL MAX_N=10005;
const LL MAX_M=100005;
#define MEF(x) memset(x,-1,sizeof(x))
#define ME0(x) memset(x,0,sizeof(x))
#define MEI(x) memset(x,inf,sizeof(x))
struct Edge
{
    int u,v,w,val,next,flow;
}edge[100005];
int first[5005],cnt=0;
void init()
{
    cnt=0;
    MEF(first);
}
inline void add(int u,int v,int w,int val)
{
    edge[cnt].u=u;
    edge[cnt].v=v;
    edge[cnt].w=w;//编号为cnt的边的最大流量
    edge[cnt].val=val;//编号为cnt的单位花费
    edge[cnt].flow=0;//编号为cnt的边流量的使用量
    edge[cnt].next=first[u];
    first[u]=cnt++;
}
int n,m,s,t,dis[5005],vis[5005],pre[10005];
bool spfa()
{
    queue<int> q;
    ME0(vis);
    MEI(dis);
    vis[s]=1;
    dis[s]=0;
    q.push(s);
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        vis[x]=0;
        for(int i=first[x];i!=-1;i=edge[i].next)
        {
            int lv=edge[i].v;
            if(edge[i].w>edge[i].flow&&dis[lv]>dis[x]+edge[i].val)
            {
                dis[lv]=dis[x]+edge[i].val;
                pre[lv]=i;//保存前驱
                if(!vis[lv])
                {
                    vis[lv]=1;
                    q.push(lv);
                }
            }
        }
    }
    if(dis[t]!=inf)
    {
        return true;
    }
    return false;
}
int ek(int &flow)
{
    int ans=0;
    while(spfa())
    {
        int mint=inf;
        for(int i=t;i!=s;i=edge[pre[i]].u)
        {
            mint=min(mint,edge[pre[i]].w-edge[pre[i]].flow);//寻找最小流量
        }
        for(int i=t;i!=s;i=edge[pre[i]].u)
        {
            edge[pre[i]].flow+=mint;
            edge[pre[i]^1].flow-=mint;
        }
        flow+=mint;
        ans+=(dis[t]*mint);
    }
    return ans;
}
int main()
{
    ios::sync_with_stdio(false);
    cin>>n>>m>>s>>t;
    init();
    for(int i=1,a,b,c,d;i<=m;i++)
    {
        cin>>a>>b>>c>>d;
        add(a,b,c,d);
        add(b,a,0,-d);
    }
    int ansf=0;
    int anss=ek(ansf);
    cout<<ansf<<' '<<anss<<endl;
    return 0;
}