最小費用最大流問題

最小費用最大流問題

最小費用最大流問題：

在最大流有多組解時，給每條邊在附上一個單位費用的量，問在知足最大流時的最小費用是多少？

來搞清楚一些概念：

• 最小費用最大流：指知足源點流出的流量最大且流量平衡時，總費用最小的一個網絡。
• 最小費用可行流：指知足流量平衡時，總費用最小的一個網絡。
• 最大費用最大流：把費用都取相反數的最小費用最大流，很容易證實等價。
• 最大費用可行流：把費用都取相反數的最小費用可行流，很容易證實等價。

思路

其實，就瞭解，解決最小費用最大流問題有兩種思路：

• 一條途徑是先用最大流算法算出最大流，而後根據邊費用，檢查是否有可能在流量平衡的前提下經過調整邊流量，使總費用得以減小。只要有這個可能，就進行這樣的調整。調整後，獲得一個新的最大流。而後，在這個新流的基礎上繼續檢查，調整。這樣迭代下去，直至無調整可能，便獲得最小費用最大流。這一思路的特色是保持問題的可行性（始終保持最大流），向最優推動。
• 另外一條途徑最大流算法思路相相似，通常首先給出零流做爲初始流。這個流的費用爲零，固然是最小費用的。而後尋找一條源點至匯點的增流鏈，但要求這條增流鏈必須是全部增流鏈中費用最小的一條。若是能找出增流鏈，則在增流鏈上增流，得出新流。將這個流作爲初始流看待，繼續尋找增流鏈增流。這樣迭代下去，直至找不出增流鏈，這時的流即爲最小費用最大流。這一算法思路的特色是保持解的最優性（每次獲得的新流都是費用最小的流），而逐漸向可行解（最大流）靠近。

通常使用第二種算法，有興趣的同窗能夠自學第一種；

算法

給出一個容量網絡，那他的最大流必定是一個定值（即便是有多個同樣的最大值）。因此咱們從開始的可行流開始增廣時，最終的增廣量是必定的。因此爲了知足最小費用咱們只須要每次找最小費用的增廣路便可，直到流量爲最大值。這個問題僅僅是在求增廣路時先考慮費用最小的增廣路，其餘思想和EK思想同樣。

代碼

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define N 5010
#define M 50010
#define INF 0x3f3f3f3f
using namespace std;
int n,m,ss,tt;
queue<int>q;
int dis[N],minv[N];
bool vis[N];
struct Edge{int to;int value;int cost;int next;}e[M<<1];
struct Pre{int id;int node;}pre[M<<1];
int head[N],cnt=-1;
void add(int from,int to,int value,int cost)
{
    cnt++;
    e[cnt].to=to;
    e[cnt].value=value;
    e[cnt].cost=cost;
    e[cnt].next=head[from];
    head[from]=cnt;
}
bool spfa(int s,int t)
{
    q=queue<int>();
    memset(dis,0x3f,sizeof(dis));
    memset(vis,0,sizeof(vis));
    memset(pre,-1,sizeof(pre));
    memset(minv,0x3f,sizeof(minv));
    dis[s]=0;
    vis[s]=1;
    q.push(s);
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        vis[x]=0;
        for(int i=head[x];i>-1;i=e[i].next)
        {
            int now=e[i].to;
            if(dis[now]>dis[x]+e[i].cost&&e[i].value)
            {
                dis[now]=dis[x]+e[i].cost;
                minv[now]=min(minv[x],e[i].value);
                pre[now].id=i;
                pre[now].node=x;
                if(!vis[now])
                {
                    vis[now]=1;
                    q.push(now);
                }
            }
        }
    }
    return dis[t]!=INF;
}
void MCMF(int s,int t,int &maxflow,int &mincost)
{
    while(spfa(s,t))
    {
        for(int i=t;i!=s;i=pre[i].node)
        {
            e[pre[i].id].value-=minv[t];
            e[pre[i].id^1].value+=minv[t];
        }
        maxflow+=minv[t];
        mincost+=minv[t]*dis[t];
    }
}
int main()
{
    memset(head,-1,sizeof(head));
    scanf("%d%d%d%d",&n,&m,&ss,&tt);
    for(int i=1;i<=m;i++)
    {
        int a,b,c,d;
        scanf("%d%d%d%d",&a,&b,&c,&d);
        add(a,b,c,d);
        add(b,a,0,-d);
    }
    int mf=0,mc=0;
    MCMF(ss,tt,mf,mc);
    printf("%d %d\n",mf,mc);
    return 0;
}