蓝桥杯·全国青少年信息素养大赛·电子学会Python/C++考级:Dinic最大流解析

进入十一月,青少儿信息学赛事进入密集备考期,几大标志性比赛的时间节点都已明确:

  • 第十八届蓝桥杯软件赛(C/C++ 程序设计、Python 程序设计都是核心科目)报名 2026-10-08 10:00 开启、2026-12-18 14:00 截止,省赛 / 全国选拔赛定于 2027 年 4 月 10 日 9:00---13:00(C/C++·Python 程序设计),全国总决赛计划 2027 年 6 月 12 日(官网 dasai.lanqiao.cn)。
  • 中国电子学会 2026 年 12 月青少年软件编程等级考试(C/C++ 一至十级、Python 一至六级)报名 9/23---12/2 16:00,全国测试 12-10 19:00---21:00,统考 12-12(C/C++ 8:30---10:30 / Python 14:00---15:00,官网 qceit.org.cn)。
  • 全国青少年信息素养大赛 2026---2027 赛季算法应用主题赛,复赛(地区赛)2027 年 5---7 月、总决赛 2027 年 7---8 月(ceic.kpcb.org.cn)。

三大赛事的算法题里,有一类「看着像应用题、写起来极考建模」的硬核考点反复出现------网络流 。而网络流的入门到实战,绕不开一个效率与优雅兼备的算法:Dinic 最大流。今天我们用一道原创题,把它从「残量网络」到「分层图 + 阻塞流」一次性讲透。


一、题目 / 项目目标

【原创题】校园科技节「供水网络最大流量调度」

学校科技节要在操场布设一套临时供水网络。整个网络有 n 个节点:1 号是水源总泵站 ,n 号是主会场 。节点之间有 m 条单向输水管道,第 i 条管道从 uᵢ 通向 vᵢ,每分钟最多能通过 cᵢ 升水(容量)。水只能顺着管道方向流动,每条管道的流量不能超过它的容量。

作为后勤工程师,请你完成两个任务:

  • 任务A :求从水源 1 号到主会场 n 号,每分钟最多能输送多少升水(最大流)。
  • 任务B :为了检修,要选若干条管道全部关闭,使得水源的水完全无法到达主会场,且这些管道的容量之和最小 (最小割)。输出这个最小容量之和。

输入格式:第一行两个整数 n、m;接下来 m 行,每行三个整数 u v c,表示一条从 u 到 v、容量为 c 的管道。

输出格式:第一行最大流,第二行最小割容量。

样例输入

复制代码
6 10
1 2 16
1 3 13
2 3 10
3 2 4
2 4 12
4 3 9
3 5 14
5 4 7
4 6 20
5 6 4

样例输出

复制代码
23
23

(两个答案恰好相等,这不是巧合------这正是著名的「最大流最小割定理」。)


二、核心考点拆解

在写代码之前,先把四个概念讲清楚,Dinic 的一切都建立在它们之上。

考点1:流网络与「流量守恒」

一张有向图,每条边有容量 c。选定源点 s (此处为 1)和汇点 t(此处为 n)。一个合法的流要满足两条:

  1. 容量限制:每条边的实际流量 f(e) ≤ 容量 c(e);
  2. 流量守恒:除源点和汇点外,任何节点「流进多少就流出多少」。

源点流出的总量 = 汇点流入的总量 = 流的值。我们要最大化这个值。

考点2:残量网络(Residual Network)------反向边的意义

这是初学者最容易懵、也最关键的一步。

对每条正向边 u→v(容量 c,当前流量 f),我们在残量网络里保留:

  • 一条正向残量边 u→v,容量 c−f(还能再推多少);

  • 一条反向残量边 v→u,容量 f(能把已经推过去的流「撤回」多少)。

为什么要有反向边? 因为贪心可能走错路。比如下面这张图:

复制代码
1 → 2 (容量 1)
1 → 3 (容量 1)
2 → 3 (容量 1)
2 → 4 (容量 1)
3 → 4 (容量 1)

如果先把仅有的 1 单位流走 1→2→3→4,那么 1→3→4 这条同样可行的路就被「2→3」卡住了。有了反向边,我们就能把 2→3 上的流撤回到 3,改走 1→3,再从 2→4 补上------最终得到流量 2。反向边让「反悔」成为可能,这是所有增广路算法的灵魂。

实现技巧:用「邻接表 + 成对存边」。每加一条边,同时压入正向边和反向边,让它们互为相邻(下标 i 与 i^1),通过 rev 指针互相找到对方,更新时一增一减。

考点3:增广路(Augmenting Path)

在残量网络里,从 s 到 t 的一条每条边残量都大于 0 的路径,叫增广路。沿着它能再推送「路径上最小残量」那么多流量。不断找增广路、不断推送,直到找不到为止------思路朴素,但找法决定效率。

  • 朴素 DFS 找增广路(Ford-Fulkerson):可能极慢;
  • BFS 找增广路(Edmonds-Karp):O(VE²),能过小规模;
  • Dinic:先 BFS 分层,再 DFS 一次性推送多条增广路------本题主角。

考点4:最大流最小割定理

一个网络的最大流值 = 它的最小割容量。

「割」就是把节点分成 S(含源点 s)和 T(含汇点 t)两组,割容量 = 所有从 S 指向 T 的边容量之和。定理保证:最大流恰好等于最小的那个割。于是任务A 和任务B 的答案天然相同。

如何求出具体的最小割? 跑完最大流后,在残量网络里从 s 出发做一次 BFS/DFS,所有能到达的点构成 S,其余是 T。此时所有从 S 指向 T 的边,其残量必然为 0(否则还能增广,矛盾),它们就是最小割。


三、解法 / 拆解:Dinic 三步走

Dinic 的每一轮分为三步,反复循环直到分层图连不通汇点。

第 1 步:BFS 建分层图

在残量网络里从 s 做 BFS,给每个节点标记层数 level[v](从 s 出发最少经过几条残边)。只有 cap > 0 的边才能走。如果汇点 t 的 level 仍是 −1,说明无法增广,算法结束。

分层图的意义:只沿着 level 恰好 +1 的方向推进,避免 DFS 在残量网络里绕圈、走回头路。

第 2 步:DFS 在分层图里推送「阻塞流」

从 s 出发做 DFS,只允许走向 level[v] == level[u] + 1 的边,把流量推到 t。一次 DFS 推送一条增广路;反复调用直到某次从 s 出发推不出任何流量(返回 0),此时称找到了一个阻塞流。

第 3 步:当前弧优化(Current Arc Optimization)

关键细节:DFS 中若某条边 u→v 已经推不动了(残量为 0,或从 v 出发推不出更多),这一轮 BFS 分层下不会再有用,不必每次都从头重试。

用一个指针数组 it[u] 记录「u 的邻接表当前处理到第几条边」。下次再从 u 出发时,直接从上次的 it[u] 继续。这一步把 Dinic 从「可能退化」拉到实用级别。

复杂度:Dinic 一般图 O(V²E),单位网络(容量都为 1,如二分图匹配)O(E√V)。对本题的数据规模绰绰有余。

参考代码(C++)

cpp 复制代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = (1LL << 60);

struct Edge { int to, rev; ll cap; };

struct Dinic {
    int n;
    vector<vector<Edge>> g;
    vector<int> level, it;
    Dinic(int n): n(n), g(n + 1), level(n + 1), it(n + 1) {}

    // 成对加边:正向 cap=c,反向 cap=0,rev 互指
    void addEdge(int u, int v, ll c) {
        Edge a{v, (int)g[v].size(), c};
        Edge b{u, (int)g[u].size(), 0};
        g[u].push_back(a);
        g[v].push_back(b);
    }

    // BFS 建分层图,返回是否能到达汇点 t
    bool bfs(int s, int t) {
        fill(level.begin(), level.end(), -1);
        queue<int> q;
        level[s] = 0; q.push(s);
        while (!q.empty()) {
            int u = q.front(); q.pop();
            for (const Edge &e : g[u])
                if (e.cap > 0 && level[e.to] == -1) {
                    level[e.to] = level[u] + 1;
                    q.push(e.to);
                }
        }
        return level[t] != -1;
    }

    // DFS 沿分层图推流,it[u] 为当前弧优化
    ll dfs(int u, int t, ll f) {
        if (u == t) return f;
        for (int &i = it[u]; i < (int)g[u].size(); ++i) {
            Edge &e = g[u][i];
            if (e.cap > 0 && level[e.to] == level[u] + 1) {
                ll ret = dfs(e.to, t, min(f, e.cap));
                if (ret > 0) {
                    e.cap -= ret;                    // 正向减少
                    g[e.to][e.rev].cap += ret;       // 反向增加
                    return ret;
                }
            }
        }
        return 0;
    }

    ll maxflow(int s, int t) {
        ll flow = 0;
        while (bfs(s, t)) {
            fill(it.begin(), it.end(), 0);           // 每轮重建分层图后重置当前弧
            ll f;
            while ((f = dfs(s, t, INF)) > 0) flow += f;
        }
        return flow;
    }

    // 残量网络从 s 可达点集 → 最小割容量
    ll minCut(int s, int t, vector<tuple<int,int,ll>> &orig) {
        vector<int> vis(n + 1, 0);
        queue<int> q; vis[s] = 1; q.push(s);
        while (!q.empty()) {
            int u = q.front(); q.pop();
            for (const Edge &e : g[u])
                if (e.cap > 0 && !vis[e.to]) {
                    vis[e.to] = 1; q.push(e.to);
                }
        }
        ll cut = 0;
        for (auto &[u, v, c] : orig)
            if (vis[u] && !vis[v]) cut += c;
        return cut;
    }
};

int main() {
    ios::sync_with_stdio(false); cin.tie(nullptr);
    int n, m; cin >> n >> m;
    Dinic dinic(n);
    vector<tuple<int,int,ll>> orig;
    for (int i = 0; i < m; ++i) {
        int u, v; ll c; cin >> u >> v >> c;
        dinic.addEdge(u, v, c);
        orig.emplace_back(u, v, c);
    }
    cout << dinic.maxflow(1, n) << '\n';
    cout << dinic.minCut(1, n, orig) << '\n';
    return 0;
}

参考代码(Python)

python 复制代码
from collections import deque

class Dinic:
    def __init__(self, n):
        self.n = n
        self.g = [[] for _ in range(n + 1)]   # e = [to, rev, cap]
        self.level = [-1] * (n + 1)
        self.it = [0] * (n + 1)

    def add_edge(self, u, v, c):
        # rev 是反向边在 g[to] 中的下标
        self.g[u].append([v, len(self.g[v]), c])
        self.g[v].append([u, len(self.g[u]) - 1, 0])

    def bfs(self, s, t):
        self.level = [-1] * (self.n + 1)
        self.level[s] = 0
        q = deque([s])
        while q:
            u = q.popleft()
            for to, rev, cap in self.g[u]:
                if cap > 0 and self.level[to] == -1:
                    self.level[to] = level = self.level[u] + 1
                    q.append(to)
        return self.level[t] != -1

    def dfs(self, u, t, f):
        if u == t:
            return f
        while self.it[u] < len(self.g[u]):
            e = self.g[u][self.it[u]]
            to, rev, cap = e
            if cap > 0 and self.level[to] == self.level[u] + 1:
                ret = self.dfs(to, t, min(f, cap))
                if ret > 0:
                    e[2] -= ret
                    self.g[to][rev][2] += ret
                    return ret
            self.it[u] += 1
        return 0

    def maxflow(self, s, t):
        flow = 0
        INF = 10 ** 18
        while self.bfs(s, t):
            self.it = [0] * (self.n + 1)
            while True:
                f = self.dfs(s, t, INF)
                if f == 0:
                    break
                flow += f
        return flow

    def min_cut(self, s, t, orig):
        vis = [False] * (self.n + 1)
        vis[s] = True
        q = deque([s])
        while q:
            u = q.popleft()
            for to, rev, cap in self.g[u]:
                if cap > 0 and not vis[to]:
                    vis[to] = True
                    q.append(to)
        return sum(c for u, v, c in orig if vis[u] and not vis[v])


n, m = map(int, input().split())
d = Dinic(n)
orig = []
for _ in range(m):
    u, v, c = map(int, input().split())
    d.add_edge(u, v, c)
    orig.append((u, v, c))
print(d.maxflow(1, n))
print(d.min_cut(1, n, orig))

Python 提示 :DFS 是递归实现,若节点数很多可在开头加 sys.setrecursionlimit(10**6);数据规模大时 Python 版 Dinic 会慢于 C++,但作为理解原理与小规模验证完全够用。


四、七个高频易错点

  1. 忘了建反向边 / 反向边容量初值写错。反向边初值必须是 0,且必须与正向边成对加、rev 互指;否则「反悔」机制失效,答案偏小。
  2. BFS 走了原图而不是残量网络 。BFS 时判断条件必须是 cap > 0(残量),不能忽略已经被用掉的流量。
  3. DFS 没按层次图走 。条件 level[to] == level[u] + 1 不能漏,否则会绕回低层节点、破坏阻塞流的正确性。
  4. 当前弧 it 忘记每轮重置 。每次 BFS 重建分层图后,必须 fill(it, 0),否则新分层下的边会被旧指针跳过。
  5. DFS 推不动时直接 return,不移动当前弧 。正确写法是用 for (int &i = it[u]; ...),推不动就自然让 i++ 试下一条边;若写错会导致大量重复尝试甚至卡死。
  6. 容量 / 流量溢出 。C++ 用 long long,INF 取 1<<60 级别;若容量和可能超过 int,别用 int。
  7. 最小割还原时点集算错 。必须从残量网络 (cap > 0)从 s 出发 BFS 得到 S;若误用原图遍历,割集会错。另外割容量要按原始容量 c 累加,不是残量。

五、进阶方向

掌握 Dinic 只是拿到网络流的入场券,下面这些是三大赛事高年级组 / 提高组的常客:

  • Edmonds-Karp:把 Dinic 的「分层 + 阻塞流」换成「BFS 找单条增广路」,复杂度 O(VE²),代码更短,适合理解增广的本质。
  • ISAP / HLPP:更快的网络流算法。ISAP(改进型最短增广路)与 Dinic 同宗;HLPP(最高标号预流推进)在稠密图上更强。
  • 最小割建模:这是网络流真正的威力所在------「最大权闭合子图」(本号 9-23 篇)、文理分科、太空飞行计划等经典题,都是把答案转化为「最小割」,再用最大流求解。
  • 二分图最大匹配 → 最大流:建超级源连左部、左连右容量 1、右连超级汇,最大流即最大匹配(本号 9-06 篇的匈牙利算法可对照)。
  • 最小费用最大流:在流的基础上给边加费用,求「流量最大且总费用最小」(本号 9-22 篇)。
  • 多源多汇 / 上下界网络流:建超级源汇、拆点限流等技巧,能解决更复杂的实际调度问题。

六、小结与互动

今天我们用一个「供水调度」的原创题,完整走了一遍 Dinic 最大流:

  • 残量网络 + 反向边让「反悔」成为可能,是所有增广路算法的地基;
  • BFS 分层图 + DFS 阻塞流让 Dinic 一次推送多条增广路;
  • 当前弧优化把重复尝试降到最低,是效率的关键;
  • 最大流最小割定理把「最大输送量」和「最小切断代价」统一成一个答案。

网络流的难点从不在代码模板(Dinic 只有几十行),而在如何把现实问题抽象成源点、汇点和容量------这正是蓝桥杯、信息素养大赛、电子学会考级最看重的建模能力。建议你把样例手推一遍残量网络的变化过程,再独立完成「二分图最大匹配 → 最大流」的建模练习。

互动时间:你在网络流里踩过最坑的 bug 是什么?是反向边写反,还是当前弧忘重置?欢迎在评论区分享,我们一起排雷。如果这篇讲透了 Dinic,点个赞 + 收藏,后续会继续拆解「最小割建模」的经典真题。


本文为原创算法解析,配套练习题与备赛资料见文末网盘链接,祝各位备赛顺利!


📚 免费少儿编程资料(夸克网盘领取)

以下资料来自夸克网盘分享,点击链接可直接保存;若需在 App 内打开,也可复制下方明文链接:

  1. 全国青少年信息素养大赛复赛集训题目Python&C++.docx
    https://pan.quark.cn/s/93995d3cb150
  2. 2024信息素养-智能算法应用挑战赛-复赛初中组题目7月7日.pdf
    https://pan.quark.cn/s/da97b5dbf75d
  3. Python背记手册.pdf
    https://pan.quark.cn/s/7568ae9ca92b
  4. Python课程
    https://pan.quark.cn/s/a94bf02d00c6
  5. 2024信息素养大赛图形化复赛集训题答案3-9
    https://pan.quark.cn/s/6ccab7ec3cbc
  6. 2025年03月份电子学会考级真题
    https://pan.quark.cn/s/4403c4228912
  7. 2025全国青少年信息素养大赛赛项说明
    https://pan.quark.cn/s/d9d0df4a9f29
  8. 青少儿信息素养大赛编程资料
    https://pan.quark.cn/s/4ab6bd83be8a

资料持续更新,关注获取最新分享。

相关推荐
开开心心就好34 分钟前
显示器关不掉怎么办,用小工具一键息屏
算法·智能手机·pdf·计算机外设·ocr·lua·1024程序员节
专注仿真44 分钟前
基于 AFSIM 的智能体训练:多智能体强化学习篇 —— QTRAN 算法实战
开发语言·python·算法·php·强化学习·afsim智能体·仿真训练
FR02EN7771 小时前
[LeetCode] 26、80.删除有序数组中的重复项 题解
数据结构·算法
草莓熊Lotso1 小时前
【C++ 基于微服务的即时通讯系统】用户服务之Redis数据层落地:会话、登录状态与验证码全封装
数据库·c++·redis·微服务·语音识别
西西弗Sisyphus2 小时前
C++ 里 两个独立的所有权域之间没有建立同步的问题
c++
2601_967987372 小时前
Python类变量和实例变量(类属性和实例属性)
python·类变量·实例变量·类属性·实例属性
CyrusYiVPP2 小时前
新用户第二周还剩几个?pandas做留存率cohort分析,数据分析实战第6期
人工智能·python
岁月宁静12 小时前
五、《从零手撸 Agent》 — 什么是 Agent:从“会聊天”到“会做事”,差的就是一个循环
python·agent
个 人 练 习 生12 小时前
C++:从零基础到深入了解vector的使用
开发语言·c++·经验分享·学习·程序人生·stl