网络最大流（EK算法)

引入：网络（network）是指一个特殊的有向图 ，其与一般有向图的不同之处在于有容量和源汇点。网络流主要有三个重要问题，最大流，最小割，费用流。

在一个网络E中每条边都有一个被称为容量的权值，有俩个特殊的点叫做源点和汇点

性质：

1. 容量限制：对于每条边，流经该边的流量不得超过该边的容量，
2. 流守恒性：除源汇点外，任意结点  的净流量为 0

满足这俩条性质的就被称为一个可行流。

一些概念：

1，增广路径：

2，残留网络：

这俩个概念自己去了解，因为文字叙述感觉讲不清楚，但是搞图太麻烦，所以自己去了解一下这俩个概念

求最大流的方法有很多种：EK,Dinic,ISAP..这些算法的都基于一个FF(Ford-Fulkerson)的思想，也不是都要求掌握，一般只要会EK,和Dinic,Dinic是EK,的优化，ISPA的效率又比Dinic的稍快，但是j基本上Diniic都能解决，一般不会卡。

EK算法主要就俩个步骤：1，找增广路   2，更新残留网络

代码奉上，注释更详细：

#include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
typedef long long LL;
typedef double D;
const int N = 2e5 + 10;
typedef pair<int, int> Pii;
int n, m, S, T;
const int inf = 1e9;
int e[N], ca[N], ne[N], h[N], idx;
void add(int a, int b, int c)//链式前向星建图
{
   ca[idx] = c;
   e[idx] = b;
   ne[idx] = h[a];
   h[a] = idx++;
}
int d[N];//能走到i点的最大流量
int pre[N];//记录到达j点的边
int st[N];//路径中的集合
int bfs()
{
   queue<int> q;
   q.push(S);
   //都初始化
   memset(d, 0, sizeof d);
   memset(st, 0, sizeof st);
   d[S] = inf;//初始化原点
   st[S] = 1;
   while (!q.empty())
   {
      auto tt = q.front();

      q.pop();
      for (int i = h[tt]; i != -1; i = ne[i])
      {
         int v = e[i];

         if (ca[i] && !st[v])//如果tt-->v的路径上，还有容量，并且v点还没有在这个路径上
         {
            q.push(v);
            st[v] = 1;
            pre[v] = i;//记录到达v点的边
            d[v] = min(d[tt], ca[i]);

         }
      }
   }
   if (d[T])//如果到达T点的最大流量大于0
      return 1;
   else
      return 0;
}
int ek()
{

   int res = 0;
   //注意；bfs每次找到的都是最短的
   while (bfs())//找增广路，如果能找到就一直找，但是每次就只能找到一个
   {
      res += d[T];
      for (int i = T; i != S; i = e[pre[i] ^ 1])//更新残留网络
      {
         ca[pre[i]] -= d[T];//正向边减
         ca[pre[i] ^ 1] += d[T];//反向边加
      }
   }
   return res;
}
void solved()
{
   cin >> n >> m >> S >> T;
   memset(h, -1, sizeof h);
   //注意这个图维护的是残留网络
   while (m--)
   {
      int a, b, c;
      cin >> a >> b >> c;
      add(a, b, c); // 建图
      add(b, a, 0);
   }
   cout << ek();
}
int main()
{
   ios::sync_with_stdio(false);
   cin.tie(0);
   cout.tie(0);
   int t;
   t = 1;
   while (t--)
   {
      solved();
   }
   return 0;
}