费用流模板 （最大最小费用流）

摘自黄大神模板

           什么是费用流？

          顾名思义，费用流就是有费用的网络流，而一般费用流指用于解决带费用的最大流，即最小费用最大流和最大费用最大流。那么费用流的模型是怎样的呢？

简单的模型如下：

    

好吧，还是这个图，只是现在的水管是收费的了，按流量计

那么费用流与最大流有什么关系呢？

           其实最大流就是费用流的一种特例，也就是费用全为零的情况，你可以试试用费用流的模板来做最大流，

当然，答案依旧是正确的，就是效率低点，费用流就是在保证流量最大的情况下使得费

用取得最值、、、

最短路也是费用流的特例，就是容量全为1 的情况，这么看来，费用流就是最短路与最大流的结合，从它

的模板我们也可以看出这点

#include
#include
using namespace std;
const int oo=1e9;
const int mm=11111;
const int mn=888;
int node,src,dest,edge;
int ver[mm],flow[mm],cost[mm],next[mm];
int head[mn],dis[mn],p[mn],q[mn],vis[mn];
/**这些变量基本与最大流相同，增加了
cost 表示边的费用，
p 记录可行流上节点对应的反向边
*/
void prepare(int _node,int _src,int _dest)
{
    node=_node,src=_src,dest=_dest;
    for(int i=0; i=mn)?l=0:l)
        for(i=head[u=q[l]],vis[u]=0; i>=0; i=next[i])
            if(flow[i]&&dis[v=ver[i]]>(tmp=dis[u]+cost[i]))
            {
                dis[v]=tmp;
                p[v]=i^1;
                if(vis[v])continue;
                vis[q[r++]=v]=1;
                if(r>=mn)r=0;
            }
    return p[dest]>-1;
}
/**源点到汇点的一条最短路即可行流，不断的找这样的可行流*/
int SpfaFlow()
{
    int i,ret=0,delta;
    while(spfa())
    {
        /**按记录原路返回求流量*/
        for(i=p[dest],delta=oo; i>=0; i=p[ver[i]])
            if(flow[i^1]=0; i=p[ver[i]])
            flow[i]+=delta,flow[i^1]-=delta;
        ret+=delta*dis[dest];
    }
    return ret;
}

下面这个好像更快

#include 
#include 

using namespace std;

const int oo=1e9;//无穷大
const int maxm=1111111;//边的最大数量，为原图的两倍
const int maxn=2222;//点的最大数量

int node,src,dest,edge;//node节点数，src源点，dest汇点，edge边数
int head[maxn],p[maxn],dis[maxn],q[maxn],vis[maxn];//head链表头，p记录可行流上节点对应的反向边，dis计算距离

struct edgenode
{
    int to;//边的指向
    int flow;//边的容量
    int cost;//边的费用
    int next;//链表的下一条边
} edges[maxm];

void prepare(int _node,int _src,int _dest);
void addedge(int u,int v,int f,int c);
bool spfa();

inline int min(int a,int b)
{
    return a=maxn)?l=0:1))
    {
        for (i=head[u=q[l]],vis[u]=false; i!=-1; i=edges[i].next)
        {
            if (edges[i].flow&&dis[v=edges[i].to]>(tmp=dis[u]+edges[i].cost))
            {
                dis[v]=tmp;
                p[v]=i^1;
                if (vis[v]) continue;
                vis[q[r++]=v]=true;
                if (r>=maxn) r=0;
            }
        }
    }
    return p[dest]>=0;
}

int spfaflow()
{
    int i,ret=0,delta;
    while (spfa())
    {
        //按记录原路返回求流量

        for (i=p[dest],delta=oo; i>=0; i=p[edges[i].to])
        {
            delta=min(delta,edges[i^1].flow);
        }
        for (int i=p[dest]; i>=0; i=p[edges[i].to])
        {
            edges[i].flow+=delta;
            edges[i^1].flow-=delta;
        }
        ret+=delta*dis[dest];
    }
    return ret;
}