费用流

费用流：

定义：

给定一个网络 $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;
}