网络最大流 Dinic【模板】带简单注释

【模板】网络最大流

类型题目描述

如题，给出一个网络图，以及其源点和汇点，求出其网络最大流。

输入格式

第一行包含四个正整数 $n,m,s,t$，分别表示点的个数、有向边的个数、源点序号、汇点序号。

接下来 $m$ 行每行包含三个正整数 $u_i,v_i,w_i$，表示第 $i$ 条有向边从 $u_i$ 出发，到达 $v_i$，边权为 $w_i$（即该边最大流量为 $w_i$）。

输出格式

一行，包含一个正整数，即为该网络的最大流。

样例 #1

样例输入 #1

4 5 4 3
4 2 30
4 3 20
2 3 20
2 1 30
1 3 40

样例输出 #1

50

提示

样例输入输出 1 解释

题目中存在 $3$ 条路径：

• $4\to 2\to 3$，该路线可通过 $20$ 的流量。
• $4\to 3$，可通过 $20$ 的流量。
• $4\to 2\to 1\to 3$，可通过 $10$ 的流量（边 $4\to 2$ 之前已经耗费了 $20$ 的流量）。

故流量总计 $20+20+10=50$。输出 $50$。

---

数据规模与约定

• 对于 $30\%$ 的数据，保证 $n\le 10$，$m\le 25$。
• 对于 $100\%$ 的数据，保证 $1\le n\le 200$，$1\le m\le 5000$，$0\le w<2^{31}$。

代码板子

#include <bits/stdc++.h>
#define buff                     \
   ios::sync_with_stdio(false); \
   cin.tie(0);
#define int long long
#define INF 1e18
using namespace std;
const int N = 209, M = 10009;
int n, m, beg, ed;
int e[M], f[M], h[N], ne[M], idx;
int d[N], cur[N];
// cur[i]代表从i这个点的哪条弧开始搜（cur[i]之前的弧都流量满了）
void add(int u, int v, int w)
{
   e[idx] = v, ne[idx] = h[u], f[idx] = w, h[u] = idx++;
   e[idx] = u, ne[idx] = h[v], f[idx] = 0, h[v] = idx++;
}
// 进行bfs，从源点开始搜，记录每层的点的层数，并初始化当前弧数组cur，搜到汇点就返回，说明找到了增广路
bool bfs()
{
   memset(d, -1, sizeof d);
   queue<int> q;
   q.push(beg);
   d[beg] = 0, cur[beg] = h[beg];

   while (q.size())
   {
       int t = q.front();
       q.pop();
       for (int i = h[t]; ~i; i = ne[i])
       {
           int j = e[i];
           // 只走之前没走过的点，并且只走容量为正的弧（因为增广路路径上的边容量都是正的）
           if (d[j] == -1 && f[i])
           {
               d[j] = d[t] + 1;
               if (j == ed)
                   return true;

               cur[j] = h[j];
               q.push(j);
           }
       }
   }
   return false;
}
// 从点idx开始走，在容量限制不超过limit的情况下，最多能多流多少流
int dfs(int idx, int limit)
{
   // 如果已经到达汇点了，那么limit的流都能流，返回limit
   if (idx == ed)
       return limit;

   int flow = 0;
   // 只从点idx的当前弧开始搜边，并且如果flow < limit（即还能增加流量）才继续搜
   for (int i = cur[idx]; ~i && flow < limit; i = ne[i])
   {
       // 更新当前弧，走到这里的时候说明i前面的弧都满了，不需要搜了
       cur[idx] = i;
       int j = e[i];
       // 只走离汇点更近的点，并且只走容量大于0的点
       if (d[j] == d[idx] + 1 && f[i])
       {
           int t = dfs(j, min(f[i], limit - flow));
           if (!t)
               d[j] = -1;  如果从v走不能增加流量了，那么v这个点以后再也不用访问了，将其层数设为-1使得以后不会再走j
           // 更新残留网络
           f[i] -= t, f[i ^ 1] += t, flow += t;
       }
   }
   return flow;
}
int dinic()
{
   int ans = 0, flow;
   // 先bfs一下看有没有增广路，如果有的话从S开始搜所有长度为S到T最短路的增广路，并累加流量
   while (bfs())
       while (flow = dfs(beg, INF))
           ans += flow;

   return ans;
}
signed main()
{
   cin >> n >> m >> beg >> ed;
   memset(h, -1, sizeof h);
   for (int i = 1; i <= m; i++)
   {
       int a, b, c;
       cin >> a >> b >> c;
       add(a, b, c);
   }

   cout << dinic() << '\n';
}