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

漂亮小姐姐点击就送：https://www.luogu.org/problemnew/show/P3381

 

 

题目描述

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

输入输出格式

输入格式：

 

第一行包含四个正整数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

样例说明：

如图，最优方案如下：

第一条流为4-->3，流量为20，费用为3*20=60。

第二条流为4-->2-->3，流量为20，费用为（2+1）*20=60。

第三条流为4-->2-->1-->3，流量为10，费用为（2+9+5）*10=160。

故最大流量为50，在此状况下最小费用为60+60+160=280。

故输出50 280。

 

// luogu-judger-enable-o2
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;

const int N=5e3+5;
const int M=5e4+5;
const int INF=0x3f3f3f3f;

int n,m,S,T;
int head[N],front[N],num_edge;
struct Edge
{
    int v,flow,cost,nxt;
}edge[M<<1];

inline int read()
{
    char c=getchar();int num=0,f=1;
    for(;!isdigit(c);c=getchar())
        f=c=='-'?-1:f;
    for(;isdigit(c);c=getchar())
        num=num*10+c-'0';
    return num*f;
}

inline void add_edge(int u,int v,int flow,int cost)
{
    edge[++num_edge].v=v;
    edge[num_edge].flow=flow;
    edge[num_edge].cost=cost;
    edge[num_edge].nxt=head[u];
    head[u]=num_edge;
}

int dis[N],vis[N],tim;
deque<int> que;
inline bool spfa(int S,int T)
{
    memset(dis,0x3f,sizeof(dis));
    ++tim;
    que.push_back(S);
    dis[S]=0;
    int now;
    while(!que.empty())
    {
        now=que.front(),que.pop_front();
        vis[now]=0;
        for(int i=head[now],v;i;i=edge[i].nxt)
        {
            if(edge[i].flow)
            {
                v=edge[i].v;
                if(dis[v]>dis[now]+edge[i].cost)
                {
                    dis[v]=dis[now]+edge[i].cost;
                    if(vis[v]!=tim)
                    {
                        if(que.empty()||dis[que.front()]<dis[v])
                            que.push_back(v);
                        else
                            que.push_front(v);
                        vis[v]=tim;
                    }
                }
            }
        }
    }
    return dis[T]!=INF;
}

int Flow,Cost;
int dfs(int now,int flow)
{
    if(now==T||!flow)
        return flow;
    int outflow=0,tmp;
    vis[now]=tim;
    for(int &i=front[now],v;i;i=edge[i].nxt)
    {
        if(edge[i].flow)
        {
            v=edge[i].v;
            if(vis[v]!=tim&&dis[now]+edge[i].cost==dis[v])
            {
                tmp=dfs(v,min(edge[i].flow,flow));
                if(tmp)
                {
                    Cost+=tmp*edge[i].cost;
                    outflow+=tmp;
                    flow-=tmp;
                    edge[i].flow-=tmp;
                    edge[i^1].flow+=tmp;
                }
                if(!flow)
                    return outflow;
            }
        }
    }
    vis[now]=0;
    dis[now]=INF;
    return outflow;
}

int main()
{
    num_edge=1;
    n=read(),m=read(),S=read(),T=read();
    for(int i=1,u,v,a,b;i<=m;++i)
    {
        u=read(),v=read(),a=read(),b=read();
        add_edge(u,v,a,b);
        add_edge(v,u,0,-b);
    }
    while(spfa(S,T))
    {
        ++tim;
        for(int i=1;i<=n;++i)
            front[i]=head[i];
        Flow+=dfs(S,INF);
    }
    printf("%d %d",Flow,Cost);
    return 0;
}

 

 

// luogu-judger-enable-o2
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;

const int N=5e3+5;
const int M=5e4+5;
const int INF=0x3f3f3f3f;

int n,m,S,T;
int head[N],num_edge;
struct Edge
{
    int u,v,flow,cost,nxt;
}edge[M<<1];

inline int read()
{
    char c=getchar();int num=0,f=1;
    for(;!isdigit(c);c=getchar())
        f=c=='-'?-1:f;
    for(;isdigit(c);c=getchar())
        num=num*10+c-'0';
    return num*f;
}

inline void add_edge(int u,int v,int flow,int cost)
{
    edge[++num_edge].v=v;
    edge[num_edge].flow=flow;
    edge[num_edge].cost=cost;
    edge[num_edge].nxt=head[u];
    head[u]=num_edge;
}

int dis[N],inque[N],tim,now;
deque<int> que;
int pre[N],path[N];
bool spfa(int S,int T)
{
    memset(dis,0x3f,sizeof(dis));
    dis[S]=0,inque[S]=++tim;
    que.push_back(S);
    while(!que.empty())
    {
        now=que.front(),que.pop_front();
        inque[now]=0;
        for(int i=head[now],v;i;i=edge[i].nxt)
        {
            v=edge[i].v;
            if(edge[i].flow>0&&dis[v]>dis[now]+edge[i].cost)
            {
                dis[v]=dis[now]+edge[i].cost;
                pre[v]=now;
                path[v]=i;
                if(inque[v]!=tim)
                {
                    if(que.empty()||dis[que.front()]<dis[v])
                        que.push_back(v);
                    else
                        que.push_front(v);
                    inque[v]=tim;
                }
            }
        }
    }
    return dis[T]<INF;
}

int Cost=0,Flow=0,flow;
void Mcmf(int S,int T)
{
    while(spfa(S,T))
    {
        flow=INF;
        for(int i=T;i!=S;i=pre[i])
            flow=min(flow,edge[path[i]].flow);
        Cost+=flow*dis[T];
        Flow+=flow;
        for(int i=T;i!=S;i=pre[i])
            edge[path[i]].flow-=flow,
            edge[path[i]^1].flow+=flow;
    }
}

int main()
{
    num_edge=1;
    n=read(),m=read(),S=read(),T=read();
    int u,v,a,b;
    for(int i=1;i<=m;++i)
    {
        u=read(),v=read(),a=read(),b=read();
        add_edge(u,v,a,b);
        add_edge(v,u,0,-b);
    }
    Mcmf(S,T);
    printf("%d %d",Flow,Cost);
    return 0;
}