网络流问题

最大流

参考博客（Ford-Fulkerson大致思想）
一些基本定理的证明
三种算法的模板
三种算法解析
Edmonds_Karp 算法 （O(VE²)）

网上普遍将使用BFS来寻找增广路的算法叫Edmonds-karp算法，使用DFS来寻找增广路的算法叫Ford-Fulkerson算法。
以上两种算法在处理下面这个图十分低效：详解

因此我们引进Dinic算法：
Dinic算法对两种寻找增广路的结合及优化，Dinic算法优于EK算法及FF算法。
Dinic算法
EK和EF算法都是每次都从s开始寻找到t的增广路，且是找到一条算一条，因此会重复很多操作。
Dinic的优化就是一次dfs寻找多条s到t的增广路（多路增广）。详见此博客
YouTube上Dinic算法的讲解
Blocking Flow 满流

最大流首题
HDU 6214
邻接图会超时，要用邻接表。
最小割集求法：
求出图达到最大流
对每条边的边权都改成（w*m+1），最后对求得的最大流%m即为结果。
m：任意大于等于边数的数；
w：边的权值；
代码

#include <cstdio>
#include <queue>
#include <string>
#include <cstring>
using namespace std;

typedef long long ll;
int const inf = 0x3f3f3f3f;
int const MAX = 205;
int n, m;
int dep[MAX];//dep[MAX]代表当前层数
int rec[MAX][MAX];//rec[u][v]表示顶点v在顶点u的vector容器中的位置
struct Node
{
   
	int to;
	ll cap;
};
vector<Node>node[MAX];

ll bfs(int s, int t)//按层次建图
{
   
    queue<int> q;
    while(!q.empty())
        q.pop();
    memset(dep, -1, sizeof(dep));
    dep[s] = 0;
    q.push(s);
    while(!q.empty()){
   
        int u = q.front();
        q.pop();
        for(auto v:node[u])
        {
   
        	if(v.cap > 0 && dep[v.to] == -1)
        	{
   
        		dep[v.to] = dep[u] + 1;
        		q.push(v.to);
        	}
        }
    }
    return dep[t] != -1;
}
 
ll dfs(int u, ll mi, int t)//查找路径上的最小流量
{
   
    if(u == t)
        return mi;
    int tmp;
    for(auto &v:node[u])//注意这里的&号，要修改到值所以要取地址
    {
   
    	if(v.cap > 0 && dep[v.to] == dep[u] + 1 && (tmp = dfs(v.to, min(mi,v.cap), t)))
    	{
   
    		v.cap -= tmp;
    		if(rec[v.to][u] == -1)//反向一开始没有边则在vector尾扩充
			{
   
				rec[v.to][u] = node[v.to].size();
				Node add;
				add.to = u; add.cap = 0;
				node[v.to].push_back(add);
    		}
    		node[v.to][rec[v.to][u]].cap += tmp;
    		return tmp;
    	}
    }
    return 0;
}
 
ll dinic(int s,int t)
{
   
    ll ans = 0, tmp;
    while(bfs(s, t)){
   
        while(1){
   
            tmp = dfs(s, inf, t);
            if(tmp == 0