网络流最大流模板（EK，dinic)

网络流算法主要用于解决给定一个容量网络和源点，汇点，求最大可通行流量的问题

增广路：源点到汇点的一条通路。

最大流问题其实就是不断找增广路的问题，我们不断找增广路，直到图中已经没有增广路的时候我们就找到了最大流，需要注意的是我们找到的增广路可能并不是最大流中的增广路，并且由于这一条增广路占用了一些边的容量，所以我们无法正确求得最大流，解决的办法就是给每条边加一个反向边，反向边的作用就相当于给了流量运输一次反悔的机会。

找增广路有许多的策略，较快的有EK算法和dinic当前弧优化算法

EK算法就是每次只找一条增广路，找完之后更新残量网络。

dinic当前弧优化算法则是每次找多条增广路，这多条增广路到源点的距离必定是一样的，并且更新残量网络的时候，那些已经榨干的路径直接删除，即cur[u]，u所连接的边，如果已经榨干，则没必要跑第二遍，所以我们通过cur[u]数组来记录u点下次要从哪个有用边开始更新

EK算法

代码:

const int MAXN = 430;
const int MAX_INT = (1 << 30);
 
struct Edge{
    int v, nxt, w;
};
 
struct Node{
    int v, id;
};
 
int n, m, ecnt;
bool vis[MAXN];
int head[MAXN];
Node pre[MAXN];
Edge edge[MAXN];
 
void init(){
    ecnt = 0;
    memset(edge, 0, sizeof(edge));
    memset(head, -1, sizeof(head));
}
 
void addEdge(int u, int v, int w){
    edge[ecnt].v = v;
    edge[ecnt].w = w;
    edge[ecnt].nxt = head[u];
    head[u] = ecnt++;
}
 
bool bfs(int s, int t){//01最短路，快速找增广路
    queue  que;
    memset(vis, 0, sizeof(vis));
    memset(pre, -1, sizeof(pre));
    pre[s].v = s;//pre数组，用于找增广路路径上的点和边，即从终点往回找
    vis[s] = true;
    que.push(s);
    while(!que.empty()){
        int u = que.front();
        que.pop();
        for(int i = head[u]; i + 1; i = edge[i].nxt){
            int v = edge[i].v;
            if(!vis[v] && edge[i].w){
                pre[v].v = u;//记录v点的父节点是u
                pre[v].id = i;//记录这条增光路v点连接的上一条边的编号是i
                vis[v] = true;
                if(v == t) return true;
                que.push(v);
            }
        }
    }
    return false;
}
 
int EK(int s, int t){
    int ans = 0;
    while(bfs(s, t)){
        int mi = MAX_INT;
        for(int i = t; i != s; i = pre[i].v){//遍历增广路上每条边的残量，取最小值
            mi = min(mi, edge[pre[i].id].w);
        }
        for(int i = t; i != s; i = pre[i].v){//增广路上每条边都减去最小残量，并且反向边加上最小残量，允许反悔
            edge[pre[i].id].w -= mi;
            edge[pre[i].id ^ 1].w += mi;
        }
        ans += mi;
    }
    return ans;
}
 
// 加边
addEdge(u, v, w);
addEdge(v, u, 0);
// 调用
int ans = EK(s, t);

dinic当前弧优化

代码:

#include
#include
#include
#include
#include
using namespace std;
#define inf 0x3f3f3f3f
const int maxn=1e2+29,maxm=2e4+2000;
struct node{
	int to,next,cap;
}edge[maxm];
int n,m,st,ed,cnt;
int dis[maxn];
int head[maxn],cur[maxn];
inline void add(int u,int v,int cap){
	edge[cnt].next=head[u];
	edge[cnt].to=v;
	edge[cnt].cap=cap;
	head[u]=cnt++;
}
bool bfs(){
    memset(dis,-1,sizeof(dis));
    queueq;
    q.push(st);
    dis[st]=0;
    int u,v;
    while(!q.empty()){
        u=q.front();
        q.pop();
        //cout<<123<