nkoj 2598||zjoj 2010

最新推荐文章于 2021-07-21 19:17:43 发布

原创最新推荐文章于 2021-07-21 19:17:43 发布 · 662 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #noip

图论专栏收录该内容

2 篇文章

订阅专栏

本文介绍了一种解决特定有向图中最大流问题的方法——最小费用最大流算法。该算法能够找出在不扩容条件下从节点1到节点N的最大流，并计算将最大流增加指定值所需的最小扩容费用。

题目：
给定一张有向图，每条边都有一个容量C和一个扩容费用W。这里扩容费用是指将容量扩大1所需的费用。求：
1.在不扩容的情况下，1到N的最大流；
2.将1到N的最大流增加K所需的最小扩容费用；

输入：第一行包含三个整数N,M,K，表示有向图的点数、边数以及所需要增加的流量。
接下来的M行每行包含四个整数u,v,C,W，表示一条从u到v，容量为C，扩容费用为W的边。
输出：包含两个整数，分别表示问题1和问题2的答案。

样例数据：
5 8 2
1 2 5 8
2 5 9 9
5 1 6 2
5 1 1 8
1 2 8 7
2 5 4 9
1 2 1 1
1 4 2 1

题解：最小费用最大流；
首先注意到有两问：
第一问
存图后直接跑一次最大流，求得MAXflow即可。
第二问：
应当分开读入原边与扩容边分开看，同时建扩容边与费用为0的边，再跑一次最小费用最大流。

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstdlib>
#include<cstring>
using namespace std;
const int inf=1e9;
const int maxn=1005;
int s,t,n,m,k,head[maxn],cnt=0,a[maxn],dis[maxn],path[maxn];
int flow,cost,u,v,c,w;
bool flag[maxn];
inline void r(int &d)
{
    bool f=false;char t=getchar();
    while(t<'0'||t>'9'){if(t=='-')f=true;t=getchar();}
    for(d=0;t>='0'&&t<='9';t=getchar())d=d*10+t-'0';
    if(f==true)d=-d;
}
struct Node{int next,from,to,cap,w;}Edges[20005];
void addedge(int u,int v,int c,int w)
{
    Edges[cnt].next=head[u];
    head[u]=cnt;
    Edges[cnt].from=u;
    Edges[cnt].to=v;
    Edges[cnt].cap=c;
    Edges[cnt].w=w;
    cnt++;
}
void insert(int u,int v,int c,int w)
{
    addedge(u,v,c,w);
    addedge(v,u,0,-w);
}
queue<int>q;
void Find(int x)
{
    flow=0,cost=0;
    while(1)
    {
        memset(a,0,sizeof(a));
        memset(dis,0x3f,sizeof(dis));
        q.push(s);
        path[s]=-1;dis[s]=0,a[s]=x?x-flow:inf,flag[s]=1;
        while(!q.empty())
        {
            int u=q.front();
            q.pop(),flag[u]=0;
            for(int i=head[u];~i;i=Edges[i].next)
            {
                int v=Edges[i].to;
                if(!x&&Edges[i].cap==inf)continue;
                if(dis[v]>dis[u]+Edges[i].w&&Edges[i].cap>0)
                {
                    dis[v]=dis[u]+Edges[i].w;
                    a[v]=min(a[u],Edges[i].cap);
                    path[v]=i;
                    if(!flag[v]){q.push(v);flag[v]=1;}
                }
            }
        }
        if(a[t]==0)break;
        flow+=a[t];
        int p=t;
        cost+=a[t]*dis[t];
        while(path[p]!=-1)
        {
            Edges[path[p]].cap-=a[t];
            Edges[path[p]^1].cap+=a[t];
            p=Edges[path[p]].from;
        }
    }
}
int main()
{
    memset(head,-1,sizeof(head));
    r(n);r(m);r(k);
    s=1,t=n;
    for(int i=1;i<=m;i++)
    {
        r(u);r(v);r(c);r(w);
        insert(u,v,c,0);
        insert(u,v,inf,w);
    }
    Find(0);
    printf("%d ",flow);
    Find(k);
    printf("%d",cost);
    return 0;
}