网络流

思路：
相当于正向流走了一部分的水流。
我们需要反过来删除掉刚才流过的水流
反向链需要添加可以返回的水流

正向链和反向链是成对出现的。
所以一旦选择了反向链表示之前走过的反向链的路径不走当前反向链。
之前的路径，传递当前含反向链路径的水流。
当前含反向链的路径传递，之前含反向链路径的水流

当前反向链路径的后续 = 之前反向链路径的 后续
之前反向链路径的后续 = 当前反向链路径的 后续
相当于 当前反向链走的水流不流了。

w[i] -= incf[T]; 
w[i ^ 1] += incf[T];

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>

using namespace std;

const int N = 1010, M = 20010;
const int inf = 0x3f3f3f3f;

int h[N], ne[M], e[M], w[M], idx;
int n, m, S, T, maxflow, pre[N], incf[N], vis[N];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

// 找一条增广路
int bfs()
{
    memset(vis, 0, sizeof vis);
    queue < int > q;
    q.push(S);vis[S] = 1;
    incf[S] = inf; // 从源点可以有无限量的水流出来
    while(q.size()){
        int u = q.front();q.pop();
        for(int i = h[u]; ~i; i = ne[i]){
            if(w[i]){ // 根据增广路的定义 只有当前边的容量大于 0
                int v = e[i];
                if(vis[v])  continue;
                incf[v] = min(w[i], incf[u]);//一条增广路上流过的最大可行流受到每条边的最小容量限制
                pre[v] = i; // 记录当前点的前驱
                q.push(v), vis[v] = 1;
                if(v == T)  return 1;
            }
        }
    }
    return 0;  //走不到终点，就不再搜索了
}

// 更新残留网络
void update()
{
    int x = T;
    while(x != S){
        int i = pre[x];
        w[i] -= incf[T]; // c(u, v) 的容量减去找到的增广路上的最小容量
        w[i ^ 1] += incf[T]; // (u, v)的方向边加上找到的增广路上的最小容量，因为插入边是成对的插入
        x = e[i ^ 1];
    }
    maxflow += incf[T]; // 累加所有增广路的最大可行流
}


int main(){
	
	cin>>n>>m;
	S=1,T=n;
	memset(h, -1, sizeof h);
	int a,b,c;
	for(int i=0;i<m;i++){
		cin>>a>>b>>c;
		add(a,b,c);
		add(b,a,0);
	}
	
	while(bfs()) update();  //走不到终点，就不再搜索了
	cout<<maxflow;
	return 0;	
}