1. 二分图在信奥赛C++提高组中的核心地位
信奥赛C++提高组（CSP-S）的题目中，二分图是一个高频出现的核心考点。作为图论中的重要概念，二分图能够将复杂问题转化为清晰的数学模型，特别适合解决匹配、覆盖等经典问题。在实际比赛中，选手需要快速识别题目中的二分图特征，并运用相应算法高效解题。
二分图判定是基础中的基础。一个无向图G=(V,E)若能将其顶点集V划分为两个不相交的子集V1和V2，使得图中每条边的两个端点分别属于这两个子集，则称G为二分图。在实际编程实现中，通常使用染色法进行判定：
bool isBipartite(vector<vector<int>>& graph) {
int n = graph.size();
vector<int> color(n, -1);
queue<int> q;
for (int i = 0; i < n; ++i) {
if (color[i] == -1) {
q.push(i);
color[i] = 0;
while (!q.empty()) {
int node = q.front();
q.pop();
for (int neighbor : graph[node]) {
if (color[neighbor] == -1) {
color[neighbor] = color[node] ^ 1;
q.push(neighbor);
} else if (color[neighbor] == color[node]) {
return false;
}
}
}
}
}
return true;
}
注意：染色法使用BFS或DFS均可，但要注意处理非连通图的情况，需要检查每个连通分量是否都是二分图。
2. 二分图匹配算法精解
2.1 匈牙利算法实现细节
匈牙利算法是解决二分图最大匹配问题的经典算法，时间复杂度为O(VE)。在竞赛中，掌握其优化版本至关重要：
vector<int> match; // 记录匹配结果
vector<bool> used; // 记录访问标记
bool dfs(int v, const vector<vector<int>>& graph) {
for (int u : graph[v]) {
if (!used[u]) {
used[u] = true;
if (match[u] == -1 || dfs(match[u], graph)) {
match[u] = v;
return true;
}
}
}
return false;
}
int hungarian(const vector<vector<int>>& graph, int n, int m) {
match.assign(m, -1);
int result = 0;
for (int v = 0; v < n; ++v) {
used.assign(m, false);
if (dfs(v, graph)) ++result;
}
return result;
}
实际比赛中常见的优化技巧包括：
- 使用邻接表而非邻接矩阵存储图结构
- 对顶点按度数排序，先处理度数小的顶点
- 使用时间戳优化used数组的初始化
2.2 Hopcroft-Karp算法的高效实现
对于大规模二分图匹配问题，Hopcroft-Karp算法（时间复杂度O(E√V)）更为高效：
const int NIL = -1;
const int INF = INT_MAX;
vector<int> pairU, pairV, dist;
vector<vector<int>> adj;
bool bfs(int nu, int nv) {
queue<int> q;
for (int u = 0; u < nu; ++u) {
if (pairU[u] == NIL) {
dist[u] = 0;
q.push(u);
} else {
dist[u] = INF;
}
}
dist[NIL] = INF;
while (!q.empty()) {
int u = q.front(); q.pop();
if (dist[u] < dist[NIL]) {
for (int v : adj[u]) {
if (dist[pairV[v]] == INF) {
dist[pairV[v]] = dist[u] + 1;
q.push(pairV[v]);
}
}
}
}
return dist[NIL] != INF;
}
bool dfs(int u) {
if (u != NIL) {
for (int v : adj[u]) {
if (dist[pairV[v]] == dist[u] + 1) {
if (dfs(pairV[v])) {
pairU[u] = v;
pairV[v] = u;
return true;
}
}
}
dist[u] = INF;
return false;
}
return true;
}
int hopcroftKarp(int nu, int nv) {
pairU.assign(nu, NIL);
pairV.assign(nv, NIL);
dist.resize(nu + 1);
int matching = 0;
while (bfs(nu, nv)) {
for (int u = 0; u < nu; ++u) {
if (pairU[u] == NIL && dfs(u)) {
++matching;
}
}
}
return matching;
}
3. 二分图在竞赛中的典型应用
3.1 最小点覆盖与König定理
König定理指出：在二分图中，最大匹配数等于最小点覆盖数。这为解决许多覆盖类问题提供了理论依据。典型应用场景包括：
- 任务分配问题：将任务和人员建模为二分图的两部
- 棋盘覆盖问题：将棋盘建模为二分图，利用行列关系
- 资源调度问题：将资源和需求抽象为二分图
实现最小点覆盖的算法步骤：
- 找到最大匹配M
- 从左侧未匹配点出发进行DFS/BFS标记可达点
- 最小点覆盖集 = 左侧未标记点 ∪ 右侧已标记点
3.2 最大独立集与团问题
在二分图中，最大独立集的大小等于顶点数减去最大匹配数。这一性质常用于解决：
- 冲突避免问题：如课程安排、活动调度
- 稳定集问题：寻找图中无直接边连接的最大顶点集
- 反图应用：将原问题的补图建模为二分图
vector<int> findMaxIndependentSet(const vector<vector<int>>& graph, int n, int m) {
int matching = hungarian(graph, n, m);
vector<bool> visited(n + m, false);
// 实现标记过程...
vector<int> result;
// 根据标记结果收集独立集顶点
return result;
}
4. 竞赛中的高级应用与变形
4.1 带权二分图与KM算法
对于带权二分图的最大权匹配问题，Kuhn-Munkres（KM）算法是标准解法。其核心思想是通过顶标调整寻找完美匹配：
vector<int> u, v, p, way;
vector<vector<int>> matrix;
int hungarian(int n, int m) {
u.assign(n + 1, 0);
v.assign(m + 1, 0);
p.assign(m + 1, 0);
way.assign(m + 1, 0);
for (int i = 1; i <= n; ++i) {
p[0] = i;
int j0 = 0;
vector<int> minv(m + 1, INT_MAX);
vector<bool> used(m + 1, false);
do {
used[j0] = true;
int i0 = p[j0], delta = INT_MAX, j1;
for (int j = 1; j <= m; ++j) {
if (!used[j]) {
int cur = matrix[i0][j] - u[i0] - v[j];
if (cur < minv[j]) {
minv[j] = cur;
way[j] = j0;
}
if (minv[j] < delta) {
delta = minv[j];
j1 = j;
}
}
}
for (int j = 0; j <= m; ++j) {
if (used[j]) {
u[p[j]] += delta;
v[j] -= delta;
} else {
minv[j] -= delta;
}
}
j0 = j1;
} while (p[j0] != 0);
do {
int j1 = way[j0];
p[j0] = p[j1];
j0 = j1;
} while (j0);
}
return -v[0];
}
4.2 二分图常见变形问题
- 多重匹配：每个顶点可以匹配多个边
- 稳定婚姻问题：考虑优先级的匹配
- 三维匹配：扩展到更高维度的匹配问题
- 网络流模型：将二分图问题转化为最大流问题
对于网络流解法，通常建立超级源点和超级汇点：
超级源点 -> 左部顶点 -> 右部顶点 -> 超级汇点
使用Dinic算法求解最大流：
struct Edge {
int to, rev, flow, cap;
};
vector<vector<Edge>> g;
vector<int> level, ptr;
void addEdge(int u, int v, int cap) {
Edge a{v, (int)g[v].size(), 0, cap};
Edge b{u, (int)g[u].size(), 0, 0};
g[u].push_back(a);
g[v].push_back(b);
}
bool bfs(int s, int t) {
level.assign(g.size(), -1);
queue<int> q;
level[s] = 0;
q.push(s);
while (!q.empty()) {
int v = q.front(); q.pop();
for (Edge &e : g[v]) {
if (level[e.to] < 0 && e.flow < e.cap) {
level[e.to] = level[v] + 1;
q.push(e.to);
}
}
}
return level[t] >= 0;
}
int dfs(int v, int t, int flow) {
if (v == t) return flow;
for (; ptr[v] < g[v].size(); ++ptr[v]) {
Edge &e = g[v][ptr[v]];
if (level[e.to] == level[v] + 1 && e.flow < e.cap) {
int f = dfs(e.to, t, min(flow, e.cap - e.flow));
if (f > 0) {
e.flow += f;
g[e.to][e.rev].flow -= f;
return f;
}
}
}
return 0;
}
int maxFlow(int s, int t) {
int flow = 0;
while (bfs(s, t)) {
ptr.assign(g.size(), 0);
while (int f = dfs(s, t, INT_MAX)) {
flow += f;
}
}
return flow;
}
5. 竞赛实战技巧与调试方法
5.1 二分图问题识别模式
在比赛中快速识别二分图问题的特征包括：
- 明显的两类对象及其关系（如学生与课程）
- 棋盘类问题的行列关系
- 匹配、覆盖、分配等关键词
- 冲突图的反图可能是二分图
5.2 常见错误与调试技巧
- 顶点编号问题：确保左右两部顶点编号不冲突
- 图存储方式：邻接表比邻接矩阵更节省空间
- 初始化问题：每次DFS前重置访问标记
- 非连通图处理：需要检查所有连通分量
调试时可以输出中间结果：
- 染色法的染色结果
- 匹配过程的中间状态
- 网络流中的流量分布
5.3 性能优化策略
- 输入优化：使用快速IO方法
- 内存预分配：避免动态扩容
- 算法选择：根据数据规模决定使用匈牙利还是HK算法
- 剪枝策略：提前终止不可能产生更优解的分支
// 快速IO示例
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
二分图作为信奥赛C++提高组的重要考点，需要选手深入理解其原理并熟练掌握多种实现方法。在实际比赛中，灵活运用二分图模型往往能将复杂问题简化为经典图论问题，从而高效求解。建议通过大量练习来培养对二分图问题的敏感度，并积累各种变形问题的解决经验。
扫一扫
2214
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
