费用流

费用流：

定义：

给定一个网络 \(G=(V,E)\), 每条边除了有容量限制 \(c(u,v)\) , 还有一个单位流量的费用 \(w(u,v)\)

当 \((u,v)\) 的流量 \(f(u,v)\) 时，需要花费 \(f(u,v) \times w(u,x)\)

\(w\) 也满足对称性，即 \(w(u,v)+w(v,u)=0\)

则该网络中总花费最小的最大流称为 最小费用最大流。

即在最大化 \(\sum_{(s,v)\in E}f(s,v)\) 的前提下最小化 \(\sum_{(u,v)\in E} f(u,v) \times w(u,v)\)

分析:

可以使用 \(SSP\) 算法。

\(SSP\) 算法是一个贪心的算法，它的思路是每次寻找单位费用最小的增广路进行增广，直到图上不存在增广路为止。

如果图上存在单位费用为负的圈， \(SSP\) 算法无法算出，需要用消圈算法消去负环。

使用：

只需要将 \(EK\) 算法或 \(Dinic\) 算法中寻找增广路的过程，替换为用最短路算法寻找单位费用最小的增广路即可。

时间复杂度为 \(O(nmk)\) ，即为 \(SPFA \times\) 增广路的长度

过程：

1. 初始化：
   \(dis\) 数组（从源点 \(s\) 到各点的最小费用）全部赋值为 \(inf\) ，用一个队列保存所有待松弛的顶点，初始时将 \(s\) 点放入队列中。
2. 队列 \(+\) 松弛操作：
   每次出队一个顶点 \(x\)，对其所有的边进行松弛，如果存在某条边 \((x,y)\) 松弛成功 \((dis(y)>dis(x)+w(x,y))\) ，则将 \(y\) 加入队列中（当 \(y\) 不在队列时).

重复以上操作直到队列为空或者发现负权环,如果网络中存在负权回路，则算法永远都不会结束，陷入死循环。

判断是否存在负权环的方法：

对任何一个顶点，每进入一次队列，意味着需要进行一次松弛，即如果某个顶点进入队列的次数超过 \(n-1\) ，说明存在负权环，因为所有点一定都遍历过一遍了。

代码：

#include<bits/stdc++.h>
using namespace std;
#define ll long long 
const int inf=0x3f3f3f3f,N=5005,M=200005;
int nxt[M],ver[M],tot=1,edge[M],head[N],w[M];
int n,m,s,t;
int maxflow,mincost;
int dis[N],pre[N],cur[N],last[N],flow[N];
bool vis[N];
queue<int> q;

void add(int x,int y,int z,int f){
    ver[++tot]=y; edge[tot]=z; nxt[tot]=head[x]; head[x]=tot; w[tot]=f;
    ver[++tot]=x; edge[tot]=0; nxt[tot]=head[y]; head[y]=tot; w[tot]=-f;
}

bool spfa(int s,int t){
    memset(dis,0x7f,sizeof(dis));
    memset(flow,0x7f,sizeof(flow));
    memset(vis,0,sizeof(vis));
    q.push(s); vis[s]=1; dis[s]=0; pre[t]=-1;
    while(!q.empty()){
        int x=q.front(); q.pop();
        vis[x]=0;
        for(int i=head[x];i;i=nxt[i]){
            int y=ver[i],z=edge[i],W=w[i];
            if(!z||dis[y]<=dis[x]+W) continue;//最短路算法
            dis[y]=dis[x]+W;
            pre[y]=x;//记录上一个点
            last[y]=i;//记录上一条边
            flow[y]=min(flow[x],z);
            if(!vis[y]){vis[y]=1; q.push(y);}
        }
    }
    return pre[t]!=-1;
}

void MCMF(){
    while(spfa(s,t)){
        int x=t;
        maxflow+=flow[x]; mincost+=flow[x]*dis[x];
        while(x!=s){
            edge[last[x]]-=flow[t];
            edge[last[x]^1]+=flow[t];
            x=pre[x];
        } 
    }
}

int main(){
    cin>>n>>m>>s>>t;
    for(int i=1,x,y,z,f;i<=m;i++){
        scanf("%d%d%d%d",&x,&y,&z,&f); add(x,y,z,f); 
    }
    MCMF();
    cout<<maxflow<<" "<<mincost<<endl;
    system("pause");
    return 0;
}

进一步分析：

网络流题目不可能像这样这么简单，如果碰到有请求的点，我们就需要判断是否需要按照点或者请求建边了。

给一道例题：

P4452 [国家集训队]航班安排

题意：

飞机飞来飞去，问获得的收益最大值(开摆！)

分析：

这题就是明显的按照请求建边，因为按照点建边，需要按时间分层。

而按照请求建边，时间则可以处理掉。

一开始 \(s=0,t=2m+2\) , \(t-1\) 为虚假的源点

源点：

先判断从 \(1\) 可不可以直接到达请求的起点，建边流量 \(inf\), 费用 \(f[1][a]\)

if(q[i].s>=times[1][q[i].a]) //能从起点飞到a点
    add(t-1,i,inf,f[1][q[i].a]);//

但是又有 \(k\) 架飞机这个条件，不知道 \(k\) 会去哪一条路，所以就再建一个真正的源点，向先前的源点（表示基地）建一条流量 \(k\) ，费用 \(0\) 的边.

汇点：

判断请求结束后能不能在规定时间内到达基地点 \(1\) ，然后建边，流量 \(inf\), 费用 \(f[b][1]\)

if(q[i].t+times[q[i].b][1]<=T) //如果能够直接回来，就建这条边
    add(i+m,t,inf,f[q[i].b][1]);

请求之间转移：

能够不回去基地，就不回去， \(m^2\) 枚举每个请求能否满足，如果满足，连边 流量 \(inf\) ,边权 \(f[b_i][a_j]\)

for(int j=1;j<=m;j++)
    if(q[i].t+times[q[i].b][q[j].a]<=q[j].s)//判断前一个结束后有时间到达后一个的开始时间
        add(i+m,j,inf,f[q[i].b][q[j].a]);
``


然后就可以快乐的 $Dinic$ 了！

```cpp
#include<bits/stdc++.h>
using namespace std;
#define ll long long 

const int N=2e5+5,M=205,inf=0x3f3f3f3f;
int n,m,K,T,s,t;
int edge[N],ver[N],head[N],nxt[N],tot=1,w[N];
int pre[N],flow[N],dis[N],last[N];
ll mincost,maxflow;
bool vis[N];
queue<int> Q;
int times[M][M],f[M][M];

struct node{
    int a,b,s,t,c;
}q[N];

void add(int x,int y,int z,int f){
    ver[++tot]=y; edge[tot]=z; w[tot]=f;  nxt[tot]=head[x]; head[x]=tot;
    ver[++tot]=x; edge[tot]=0; w[tot]=-f; nxt[tot]=head[y]; head[y]=tot;
} 

bool spfa(int s,int t){
    memset(dis,0x7f,sizeof(dis));
    memset(flow,0x7f,sizeof(flow));
    memset(vis,0,sizeof(vis));
    Q.push(s); vis[s]=1; dis[s]=0; pre[t]=-1;
    while(!Q.empty()){
        int x=Q.front(); Q.pop();
        vis[x]=0;
        for(int i=head[x];i;i=nxt[i]){
            int y=ver[i],z=edge[i],W=w[i];
            if(!z||dis[y]<=dis[x]+W) continue;
            dis[y]=dis[x]+W;
            pre[y]=x;
            last[y]=i;//记录上一条边
            flow[y]=min(flow[x],z);
            if(!vis[y]){vis[y]=1; Q.push(y);}
        }
    }
    return pre[t]!=-1;
}

void MCMF(){
    while(spfa(s,t)){
        int x=t;
        maxflow+=flow[x]; mincost+=flow[x]*dis[x];
        while(x!=s){
            edge[last[x]]-=flow[t];
            edge[last[x]^1]+=flow[t];
            x=pre[x];
        } 
    }
}

int main(){
    cin>>n>>m>>K>>T;
    s=0,t=2*m+2;//虚假的源点是 t-1
    for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) scanf("%d",&times[i][j]);
    for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) scanf("%d",&f[i][j]);
    for(int i=1;i<=m;i++){
        scanf("%d%d%d%d%d",&q[i].a,&q[i].b,&q[i].s,&q[i].t,&q[i].c);
        q[i].a++; q[i].b++;
    }
    for(int i=1;i<=m;i++){//按照请求建边
        add(i,i+m,1,-q[i].c);//按照负边权建边
        if(q[i].t+times[q[i].b][1]<=T) //如果能够直接回来，就建这条边
            add(i+m,t,inf,f[q[i].b][1]);
        else continue;//不能回家
        if(q[i].s>=times[1][q[i].a]) //能从起点飞到a点
            add(t-1,i,inf,f[1][q[i].a]);//
        for(int j=1;j<=m;j++)
            if(q[i].t+times[q[i].b][q[j].a]<=q[j].s)//判断前一个结束后有时间到达后一个的开始时间
                add(i+m,j,inf,f[q[i].b][q[j].a]);
            
    }
    add(s,t-1,K,0);//从源点到汇点控制k架飞机
    MCMF();
    cout<<-mincost<<endl;//边权取反，答案也要取反
    system("pause");
    return 0;
}