最小费用最大流的另类算法

Theory

传统上，最小费用最大流似乎就是SPFA和zkw两种求法。但是两种求法都有一些局限性，在相应的极限图上效率较低，而这个算法比较好一点的就是在极限图上的效率不至于TLE。
很明显，要使得fee最小，那么使得每一流的费用都尽量最小即可。那么就可以以费用作边权，SPFA先将整个图S到T的最小费用跑出来，在dfs求流的时候保证所走的路径是在最短路图上即可。没有增广路之后，重新算出当前的最小费用，直到S和T不联通，这样就可以在得到最大流的时候保证费用最小。注意到这个思想和Dinic的分层图比较类似，那么可以模改一下Dinic跑最小费用最大流。

优点：速度比SPFA快，在zkw费用流的极限图中还可以卡常过去
缺点：代码量大……

Code

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
using namespace std;
queue<int> q;
cosnt int INF=0x3f3f3f3f;
bool bfs(int s,int t)//求当前图的最短路
{
    memset(dis,0x3f,sizeof(dis));
    memset(inq,0,sizeof(inq));
    int x;
    dis[t]=0;
    q.push(t);
    inq[t]=true;
    while(!q.empty())
    {
        x=q.front();
        q.pop();
        inq[x]=false;
        for(int i=head[x];~i;i=edge[i].nxt)
          if(edge[i^1].w&&dis[edge[i].v]>dis[x]-edge[i].c)//从汇点出发，所以减
          {
            dis[edge[i].v]=dis[x]-edge[i].c;
            if(inq[edge[i].v])
              continue;
            inq[edge[i].v]=true;
            q.push(edge[i].v);
          }
    }
    return dis[s]<INF;
}
int dfs(int u,int flow)//同Dinic中的dfs
{
    vis[u]=true;
    if(u==t||flow==0)
      return flow;
    int used=0,w;
    for(int i=head[u];~i;i=edge[i].nxt)
      if(!vis[edge[i].v]&&edge[i].w&&dis[edge[i].v]==dis[u]-edge[i].c)
      {
        w=dfs(edge[i].v,min(edge[i].w,flow-used));
        edge[i].w-=w;
        edge[i^1].w+=w;
        used+=w;
        if(used==flow)
          return used;
      }
    return used;
}
int main()
{
    while(bfs(s,t))
    {
        vis[t]=true;
        while(vis[t])//还有最短路就继续搜
        {
            memset(vis,0,sizeof(vis));//其实这里还可以用时间戳来优化
            flow=dfs(s,INF);
            ans+=flow;
            fee+=flow*dis[s];
        }
    }
    return 0;
}