网络流初步：<最大流>——核心（增广路算法）（模板）

增广路的核心就是引入了反向边，使在进行道路探索选择的时候增加了类似于退路的东西【有一点dp的味道？？】

具体操作就是：1、首先使用结构体以及数组链表next[ MAXN ]进行边信息的存储

2、【核心】在存储正向边时，将正向边结构体数组相邻编号的元素存储反向边

　　【具体操作：如正向边为AA[0]，则对应的反向边为AA[1]，这样就可以在之后通过异或来对正向边对应的反向边进行更新】【初始时反向边的容量为0】

3、通过dfs进行寻路，寻路过程要用数组记录下来路经过的边的编号，便于在找到终点后遍历找边的最小剩余容量，然后在总流量上加上最小的剩余容量即可

4、【易错】dfs应该写成bool 型的，在找到一条路或找不到路之后直接return【而不是一直dfs到最后】，而且要在主函数中加一个for(;;)，在bool dfs 返回值为false时跳出循环即可

#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 10000+10
#define M 10000+10
#define inf 1e9;
using namespace std; 
int head[N],arnum=1,used[N],ans,way[M];
struct ss{int next,to,cap;}a[M];
void add(int from,int to,int cap){a[++arnum]=(ss){head[from],to,cap};head[from]=arnum;}
void insert(int u,int v,int cap){add(u,v,cap),add(v,u,0);}
int n,m,S,T;
void work(int step)
{
    int minn=inf;
    for(int i=1;i<=step;i++)
        minn=min(minn,a[way[i]].cap);
    ans+=minn;
    for(int i=1;i<=step;i++)
    {
        a[way[i]].cap-=minn;
        a[way[i]^1].cap+=minn;
    }
}
int dfs(int u,int step)
{
    for(int i=head[u];i;i=a[i].next)
    {
        int v=a[i].to;
        int cap=a[i].cap;
        if(not used[v] and cap>0)
        {
            way[step]=i;
            used[v]=1;
            if(v==T){work(step);return 1;}
            else if(dfs(v,step+1))return 1;
        }
        return 0;
    }
}
int main()
{
    scanf("%d%d%d%d",&n,&m,&S,&T);
    int u,v,c;
    for(int i=1;i<=m;i++){scanf("%d%d%d",&u,&v,&c);insert(u,v,c);}
    for(;;)
    {
        memset(used,0,sizeof(used));
        used[S]=1;
        if(not dfs(S,1))break;
    }
    printf("%d",ans);
    return 0;
}