网络流最大流模板（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 <int> 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<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
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));
    queue<int>q;
    q.push(st);
    dis[st]=0;
    int u,v;
    while(!q.empty()){
        u=q.front();
        q.pop();
        //cout<<123<<endl;
        for(int i=head[u];i!=-1;i=edge[i].next){
            v=edge[i].to;
            if(dis[v]==-1&&edge[i].cap){
                dis[v]=dis[u]+1;
                q.push(v);
                if(v==ed)return true;//抵达汇点即退出，因为同一个点只访问一次，一次bfs找出的增广路路径长度必定一样
            }
        }
    }
    return false;
}
int dfs(int u,int cap){
    if(u==ed||cap==0){
        return cap;
    }
    int res=0,f;//res可以理解为一个点的推送量
    for(int &i=cur[u];i!=-1;i=edge[i].next){//cur[u]主要用于删除该点所连接的已榨干的边或通路
        int v=edge[i].to;
        if(dis[v]==dis[u]+1&&(f=dfs(v,min(cap-res,edge[i].cap)))){//f是源点到当前点的最小残量
            edge[i].cap-=f;
            edge[i^1].cap+=f;
            res+=f;
            if(res==cap)return cap;//如果这个点的推送量==该点的接收量，return
        }
    }
    if(!res)dis[u]=-1;//如果推送量等于0，则该点没有可以扩展的增广路
    return res;
}
void dinic(){
    int ans=0;
    while(bfs()){
        for(int i=0;i<=n+1;i++)cur[i]=head[i];//当前弧优化
        ans+=dfs(st,inf);
       // break;
    }
    printf("%d\n",ans);
}
int main(){
	int i,j,k,np,nc;
	int x,y,z;
	char ch;
	while(scanf("%d%d%d%d",&n,&np,&nc,&m)!=EOF){
		memset(head,-1,sizeof(head));
		cnt=0;
		for(i=0;i<m;i++){
			scanf(" %c%d%c%d%c%d",&ch,&x,&ch,&y,&ch,&z);
			add(x,y,z);add(y,x,0);
		}
		st=n,ed=n+1;
		for(i=0;i<np;i++){
			scanf(" %c%d%c%d",&ch,&x,&ch,&z);
			add(st,x,z);add(x,st,0);
		}
		for(i=0;i<nc;i++){
			scanf(" %c%d%c%d",&ch,&x,&ch,&z);
			add(x,ed,z);add(ed,x,0);
		}
		dinic();
	}
}