最小费用最大流 修改的dijkstra + Ford-Fulksonff算法

最小费用最大流 修改的dijkstra + Ford-Fulksonff算法
修改的dijkstra其实和Johnson算法的思想是一致的。
 
一个求最小费用最大流的朴素算法是这样的：
1 求最小费用增广路
2 判断是否存在增广路，否的话算法终止。
3 增加增广路上边的流量
4 在增广路上添加必要的逆向负权边
5 goto 1
 
因为负权边的存在，求最小费用增广路就不可以用dijkstra算法。当然，我们可以用bellman-ford算法，可是这样的话求一次最短路的时间代价就是O(e*n)，e是边数，n是顶点数。代价大了点，如果能用dijkstra算法就好了。利用Johnson算法的思想，这是可以做到的。
 
第一次求最短路可以用dijkstra算法（如果一开始就有负权边，那就用bellman-ford算法，这没关系），求出源点到所有点的距离，嗯，我说的距离是指路径上边的费用之和的最小值。注意，要求出到所有点的距离，而不是求出到汇点的距离就完事了。
假设有一条边u->v，源点到u的距离是d[u]，到v的距离是d[v]，边的费用（权值）是w(u，v)。很显然，d[u]+w(u,v)>=d[v]，不然的话，你会发现一条更好的路径从源点到v。问题是，什么时候取等呢？当u->v在v的最优路径上，范围说小一点，当u->v在从源点到汇点的最优路径，即最小费用增广路上。
好的，如果u->v被你增载了，你要开始添负权边v->u了，权值取负，就是-w(u,v)。负权就是讨厌，是正的就好了，dijkstra算法就可以再用了。怎么办呢，把负权边加个权值，让它非负。要加多少呢，d[v]-d[u]。当然不能只加一条边，对所有边，无论原有的还是新添的，按这个规则加，构造一个新的图：
                对边a->b，新的边权w'(a,b)=w(a,b)+d[a]-d[b]
现在来看看你的杰作：
                对原来的边u->v, w'(u,v)=w(u,v)+d[u]-d[v]: 记得么d[u]+w(u,v)>=d[v], 所以 w'(u,v) >= 0
                对新加的负权边v->u, w'(v,u)=w(v,u)+d[v]-d[u]=-w(u,v)+d[v]-d[u]: 记得么d[u]+w(u,v)==d[v]，这里可是取等号的，所以w'(v,u) == 0
哈哈，这下所有边又是非负的了。
可是，问题是，为啥不每个边加个足够大的正数，这样不是所有边也都是正的了么。仔细想想，边权为啥要为正，不就是为了求源点到汇点的最短路方便么，可是，都加大正数的话，你求出的最短路和原来图的最短路能一致么，不能，为啥，画个三角形，自己想想。可是，我的方法就能一致么，能。我证明给你看。
 
假设从源点s到汇点t有一条路径s->a->b->c->d.->t,在原图中的路径长度为
                 w(s,a)+w(a,b)+w(b,c)++w(x,t)
在新图中的路径为
                 w'(s,a)+w'(a,b)+w'(b,c)+w'(x,t)
展开来就是
                 w(s,a)+d[a]-d[s]+w(a,b)+d[b]-d[a]+w(c,d)+d[d]-d[b]+.+w(x,t)+d[t]-d[x]
消阿消，d[a]和-d[a]，d[b]和-d[b]d[x]和-d[x]，剩下什么呢：
                 w(s,a)+w(a,b)+w(b,c)++w(x,t)+d[t]-d[s]
噢，不就比原图中多d[t]-d[s]么（其实d[s]==0）。这可是对所有s到t的路径都成立的，既然所有路径，在新图中的权值都比在原图中的权值多了d[t]，那么，新图的最短路，也就对应原图的最短路，只不过路径长度多了d[t]，这不仅对t成立，对所有节点u都成立，只不过新图中到u的最短路长度比原图多了d[u]。
 
好，用dijkstra算法，第二次求出最短路。然后求出新的d’[u]，然后添加新的边，然后准备第三次的dijkstra算法。。。为什么第二次可以这样做，第三次还可以这样做，第三次的原图可能有很多负权边啊？我可没说过w(u,v)>=0这样的限制，所以，即使原图有负权边还是可以这样做的。
 
好了，第一次dijkstra算法（或者bellman-ford算法，如果有负权边的话，只用一次，不会成为瓶颈的），然后每次求最小增广路用一次修改的dijkstra算法。这个算法求最小费用最大流复杂度是O(m*n*n), m是最大流量，或者是求增广路次数的上界。最后，如果用这个算法来求最优匹配问题，复杂度是O(n^3)的。

 

/*

    Created by mowenwen

     ~~~~   2015.10.01

*/

 

#include <iostream>

#include <cstdio>

#include <cstring>

#include <algorithm>

#include <cmath>

#include <queue>

using namespace std;

#define maxn 10000+10

#define inf 0x7fffffff

int k, p;

int tot;

int head[maxn],flag[maxn],p1[maxn],p2[maxn],dis[maxn];

struct Edge

{

    int to,next,c,f;

}edge[80010];

void addedge(int u,int v,int c,int f)

 

    int i;                         //去重边

    for(i = head[u];i != -1;i = edge[i].next)

    {

        if(edge[i].to == v)

            break;

    }

    if(i != -1)

    {

        if(f < edge[i].f)

        {

            edge[i].f = f;

            edge[i^1].f = -f;

        }

        return;

    }

    edge[tot].next = head[u];

    edge[tot].to = v;

    edge[tot].c = c;

    edge[tot].f = f;

    head[u] = tot ++;

    edge[tot].next = head[v];

    edge[tot].to = u;

    edge[tot].c = 0;

    edge[tot].f = -f;

    head[v] = tot ++;

    return;

}

bool spfa(int s, int t)

{

    queue<int> q;

    memset(flag, 0, sizeof(flag));

    memset(p1, -1, sizeof(p1));

    memset(p2, -1, sizeof(p2));

    for(int i = 0;i <= t;i ++)

    dis[i] = inf;

    q.push(s);

    dis[s] = 0;

    flag[s] = 1;

    while(!q.empty())

    {

        int u = q.front();

        q.pop();

        flag[u] = 0;

        for(int i = head[u]; i != -1; i = edge[i].next)

        {

           if(edge[i].c)

           {

               int v = edge[i].to;

               if(dis[v] > dis[u] + edge[i].f)

               {

                   dis[v] = dis[u] + edge[i].f;

                   p1[v] = u;      //当前点的前驱

                   p2[v] = i;      //当前点所连的边

                   if(!flag[v])

                   {

                       q.push(v);

                       flag[v] = 1;

                   }

 

               }

           }

 

        }

    }

    if(dis[t] == inf) return false;

    else return true;

}

int min_cost_flow(int s,int t)

{

   int ans_cost = 0;

   int u, minn;

   while(spfa(s, t))

   {

       u = t;

       minn = inf;

       while(p1[u] != -1)

       {

           minn = min(minn, edge[p2[u]].c);

           u = p1[u];

       }

       //cout << minn <<endl;

       u = t;

       while(p1[u] != -1)

       {

           edge[p2[u]].c -= minn;

           edge[p2[u] ^ 1].c += minn;

           u = p1[u];

       }

       ans_cost += dis[t] * minn;

       //cout << ans_cost<<endl;

   }

   return ans_cost;

}

void init()

{

     memset(head, -1, sizeof(head));

     tot = 0;

}

int main()

{

    int t, n, m, u, v, w;

    scanf("%d", &t);

    while(t --)

    {

        scanf("%d%d", &n, &m);

        for(int i = 0;i < m;i ++)

        {

            scanf("%d%d%d",&u, &v, &w);

            addedge(u, v+n, 1, w);

        }

        for(int i = 1;i <= n;i ++)

        {

            addedge(0, i, 1, 0);

        }

        for(int i = n+1;i <= 2*n;i ++)

        {

            addedge(i, 2*n+1, 1, 0);

        }

        int ans = min_cost_flow(0, 2*n+1);

        printf("%d\n", ans);

    }

    return 0;

}
 

 

 

第二种

#include<iostream>

using namespace std;

 

int n,ans;

int cap[MAX][MAX];//容量

int pre[MAX];//用于保存增广路径

int cost[MAX][MAX];//花费

int dis[MAX];//源点到每个点（包括汇点）的距离

int que[MAX];//用于SPFA算法中的队列

bool vis[MAX];//访问标记数组

 

bool spfa()//源点为0，汇点为n

{

    int i;

    int head=0;//队头

    int tail=1;//队尾

    for(i=0;i<=n;i++)//每次都要初始化

    {

        dis[i]=inf;

        vis[i]=false;

    }

    dis[0]=0;

    que[0]=0;

    vis[0]=true;

    while(tail!=head)//循环队列

    {

        int u=que[head];

        for(i=0;i<=n;i++)

        {

            if(cap[u][i]&&dis[i]>dis[u]+cost[u][i])//松弛

            {

                dis[i]=dis[u]+cost[u][i];

                pre[i]=u;

                if(!vis[i])

                {

                    vis[i]=true;

                    que[tail++]=i;

                    if(tail==MAX)//tail的范围是:0~MAX-1

                        tail=0;

                }

            }

        }

        vis[u]=false;

        head++;

        if(head==MAX)

            head=0;

    }

    if(dis[n]==inf)//因为n是汇点，所以可以用dis[n]是否等于inf来判断能否找到增广路

        return false;

    return true;//找到一条增广路pre[]，这条增广路还是最短的（花费最少的）

}

void mcmf()

{

    int i;

    int temp=inf;

    for(i=n;i!=0;i=pre[i])

        temp=min(temp,cap[pre[i]][i]);//找出增广路径中最小的残余流

    for(i=n;i!=0;i=pre[i])//消灭那条残留网络

    {

        cap[pre[i]][i]-=temp;//流的反对称性:f(u,v)=-f(v,u)

        cap[i][pre[i]]+=temp;

        ans+=cost[pre[i]][i]*temp;//cost[][]记录的单位流量费用，必须得乘以流量。

    }

}

int main()

{

    //...

    ans=0;

    while(spfa())

        mcmf();

    //...

    return 0;

}