dinic求最大流 复杂度m*n^2
个人对反向边的存在的理解：当没有流到最优路线的时候，给一个反悔的机会
增广路：从s到t的一条路径 正向边流量全部不满capacity 反向边的流量全部>0，跑了可以使最大容量增加，dinic就是增广路算法
引用luogu上的大佬的dinic算法的过程：
1.先利用BFS对残余网络分层 一个节点的深度，就是源点到它最少要经过的边数。
2.利用BFS对残余网络分层，分完层后，利用DFS从前一层向后一层反复寻找增广路。
3.分完层后，从源点开始，用DFS从前一层向后一层反复寻找增广路(即要求DFS的每一步都必须要走到下一层的节点）。 因此，前面在分层时，只要进行到汇点的层次数被算出即可停止，因为按照该DFS的规则，和汇点同层或更下一层的节点，是不可能走到汇点的。
4.DFS过程中，要是碰到了汇点，则说明找到了一条增广路径。此时要增加总流量的值，消减路径上各边的容量，并添加反向边，即所谓的进行增广。
5.DFS找到一条增广路径后，并不立即结束，而是回溯后继续DFS寻找下一个增广路径。 回溯到哪个节点呢？ 回溯到的节点u满足以下条件：
6.DFS搜索树的树边(u,v)上的容量已经变成0。即刚刚找到的增广路径上所增加的流量，等于(u,v)本次增广前的容量。(DFS的过程中，是从u走到更下层的v的)
u是满足条件 1)的最上层的节点如果回溯到源点而且无法继续往下走了，DFS结束。 因此，一次DFS过程中，可以找到多条增广路径。
7.DFS结束后，对残余网络再次进行分层，然后再进行DFS当残余网络的分层操作无法算出汇点的层次（即BFS到达不了汇点）时，算法结束，最大流求出。
luogu P3376 【模板】网络最大流
#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+5;
const int maxm=1e6+5;
const int inf=0x3f3f3f3f;
int dep[maxn],inque[maxn];
int top=1;
int maxflow,n,m,s,t;
struct edge{
int v,w,rev;
};
vector<edge>e[2*maxm];
inline void add_edge(int u,int v,int w){
e[u].push_back((edge){v,w,e[v].size()});
e[v].push_back((edge){u,0,e[u].size()-1});
}
bool bfs(){
memset(dep,inf,sizeof(dep));
memset(inque,0,sizeof(inque));
dep[s]=0;
queue<int>q;
q.push(s);
while(!q.empty()){
int u=q.front();
q.pop();
inque[u]=0;
for(int i=0;i<e[u].size();i++){
int v=e[u][i].v;
edge x=e[u][i];
if(dep[v]>dep[u]+1&&x.w){
dep[v]=dep[u]+1;
if(inque[v]==0){
q.push(v);
inque[v]=1;
}
}
}
}
if(dep[t]!=inf)return true;
return false;
}
int dfs(int u,int flow){
int rlow=0;
if(u==t)return flow;
for(int i=0;i<e[u].size();i++){
int v=e[u][i].v;
if(e[u][i].w&&dep[v]==dep[u]+1){
if(rlow=dfs(v,min(flow,e[u][i].w))){
e[u][i].w-=rlow;
e[v][e[u][i].rev].w+=rlow;
return rlow;
}
}
}
return 0;
}
int dinic(){
int lowflow;
while(bfs()){
while(lowflow=dfs(s,inf))maxflow+=lowflow;
}
return maxflow;
}
int main(){
scanf("%d%d%d%d",&n,&m,&s,&t);
int u,v,w;
for(int i=1;i<=m;i++){
scanf("%d%d%d",&u,&v,&w);
add_edge(u,v,w);
}
printf("%d",dinic());
return 0;
}
最小费用最大流的思路其实跟最大流差不多，用spfa代替bfs，再跑dfs进行增广，同时累加最大流
把dfs中的dep[v]==dep[u]+1改成dis[v]==dis[u]+c（c是这条边的费用），用一个数组used记录该点用了的流量
时间复杂度nmf
vis数组来避免存在费用为0的边让程序陷入死循环
luogu P3381 【模板】最小费用最大流
#include<bits/stdc++.h>
using namespace std;
const int inf=0x3f3f3f3f,maxn=5e3+5,maxm=5e4+5;
int n,m,s,t,cost,maxflow,vis[maxn],dis[maxn];
struct edge{
int v,flow,cost,rev;
};
vector<edge>e[maxm*2];
inline void add_edge(int u,int v,int flow,int cost){
e[u].push_back((edge){v,flow,cost,e[v].size()});
e[v].push_back((edge){u,0,-cost,e[u].size()-1});
}
bool spfa(){
memset(vis,0,sizeof(vis));
memset(dis,inf,sizeof(dis));
dis[s]=0;
vis[s]=1;
queue<int>q;
q.push(s);
while(!q.empty()){
int u=q.front();
q.pop();
vis[u]=0;
for(int i=0;i<e[u].size();i++){
int v=e[u][i].v;
int c=e[u][i].cost;
if(dis[v]>dis[u]+c&&e[u][i].flow){
dis[v]=dis[u]+c;
if(vis[v]==0){
q.push(v);
vis[v]=1;
}
}
}
}
if(dis[t]!=inf)return true;
return false;
}
int dfs(int u,int flow){
if(u==t){
vis[t]=1;
maxflow+=flow;
return flow;
}
int used=0;
vis[u]=1;
for(int i=0;i<e[u].size();i++){
int v=e[u][i].v;
int c=e[u][i].cost;
if((vis[v]==0||v==t)&&e[u][i].flow!=0&&dis[v]==dis[u]+c){
int minflow=dfs(v,min(flow-used,e[u][i].flow));
if(minflow!=0){
cost+=c*minflow;
e[u][i].flow-=minflow;
e[v][e[u][i].rev].flow+=minflow;
used+=minflow;
if(used==flow)break;
}
}
}
return used;
}
int mcmf(){
while(spfa()){
vis[t]=1;
while(vis[t]){
memset(vis,0,sizeof(vis));
dfs(s,inf);
}
}
return maxflow;
}
int main(){
scanf("%d%d%d%d",&n,&m,&s,&t);
int u,v,f,w;
for(int i=1;i<=m;i++){
scanf("%d%d%d%d",&u,&v,&f,&w);
add_edge(u,v,f,w);
}
mcmf();
printf("%d %d",maxflow,cost);
return 0;
}
网络流的算法其实挺少（主动无视FF EK 那些不够高效的算法和ISAP HLPP这种卡极致复杂度的算法）
难点主要在于建模，慢慢练习积累建图经验。
立个flag（2020年结束之前a掉50题网络流&图匹配） （逃