图论与贪心算法实战：犯罪网络打击策略-代码聚汇网

图论与贪心算法实战：犯罪网络打击策略

金宇澄

1. 题目背景与核心需求解析

这道来自《信息学奥赛一本通》P1386的"打击犯罪(black)"题目，是典型的图论与贪心算法结合的应用题。题目描述了一个犯罪网络模型：N个犯罪团伙之间形成了一张无向图，每条边表示两个团伙之间存在合作关系。我们的任务是找到最优的打击顺序，使得每次打击一个团伙后，剩余网络中最大连通块的大小不超过N/2。

这类题目在NOIP/NOI中属于中等难度，考察选手对图论基础算法（如并查集、DFS/BFS）和贪心策略的综合运用能力。实际解题时需要处理以下几个关键点：

如何高效维护动态变化的网络结构
如何评估每个节点的打击优先级
如何快速判断当前最大连通块规模

2. 算法设计与实现思路

2.1 逆向思维的应用

常规思路是从原始网络开始逐个删除节点，但这样每次删除后都需要重新计算连通性，时间复杂度高达O(N^3)。更聪明的做法是逆向思考——从空图开始逐步添加节点：

初始化所有节点为孤立状态
按编号从大到小依次"恢复"节点（即题目中的逆向删除）
每次恢复后立即检查最大连通块是否超过N/2
当首次触发条件时，当前未恢复的节点数就是最小打击数

这种逆向处理的关键优势在于：

并查集的合并操作比分割操作容易实现
只需处理一次边的连接关系
可以提前终止计算

2.2 并查集优化实现

并查集(Disjoint Set Union)是解决此问题的理想数据结构，需要实现以下核心操作：

cpp复制int parent[MAXN], size[MAXN];

void init() {
    for(int i=1; i<=n; i++) {
        parent[i] = i;
        size[i] = 1;
    }
}

int find(int x) {
    return parent[x] == x ? x : parent[x] = find(parent[x]);
}

void unite(int x, int y) {
    x = find(x);
    y = find(y);
    if(x == y) return;
    if(size[x] < size[y]) swap(x, y);
    parent[y] = x;
    size[x] += size[y];
    max_size = max(max_size, size[x]);
}

特别注意：

采用路径压缩和按秩合并优化
维护一个全局变量max_size追踪当前最大连通块
合并时总是将小树合并到大树下

3. 完整解题代码与注释

cpp复制#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 1010;
vector<int> graph[MAXN];
int parent[MAXN], size[MAXN];
int n, max_size;

void init() {
    for(int i=1; i<=n; i++) {
        parent[i] = i;
        size[i] = 1;
    }
    max_size = 1;
}

int find(int x) {
    return parent[x] == x ? x : parent[x] = find(parent[x]);
}

void unite(int x, int y) {
    x = find(x);
    y = find(y);
    if(x == y) return;
    if(size[x] < size[y]) swap(x, y);
    parent[y] = x;
    size[x] += size[y];
    max_size = max(max_size, size[x]);
}

int solve() {
    init();
    int ans = n;
    for(int i=n; i>=1; i--) {
        for(int v : graph[i]) {
            if(v > i) {  // 只连接已恢复的节点
                unite(i, v);
            }
        }
        if(max_size > n/2) {
            ans = i - 1;
            break;
        }
    }
    return ans;
}

int main() {
    cin >> n;
    for(int i=1; i<=n; i++) {
        int m, v;
        cin >> m;
        while(m--) {
            cin >> v;
            graph[i].push_back(v);
        }
    }
    cout << solve() << endl;
    return 0;
}

关键实现细节：

使用邻接表存储原始网络
从编号n到1逆向处理
只连接比当前节点编号大的邻居（模拟恢复过程）
实时监测max_size的变化

4. 算法复杂度分析

时间复杂度：

初始化：O(N)
并查集操作：近似O(α(N))每次，其中α是反阿克曼函数
总体：O(Mα(N))，M为总边数

空间复杂度：

邻接表存储：O(N+M)
并查集结构：O(N)

相比正向删除的O(N^3)暴力解法，这个逆向方法将复杂度降低到了接近线性水平，能够高效处理N=1000规模的数据。

5. 常见问题与调试技巧

5.1 边界条件处理

容易出错的特殊情况包括：

N=1时的除零问题
所有连通块都小于N/2时应返回0
节点编号是否从1开始

调试建议：

cpp复制// 在solve()函数中加入调试输出
cout << "Processing node " << i << ", current max_size: " << max_size << endl;

5.2 性能优化验证

对于大规模数据（如N=1000）：

检查是否使用了路径压缩和按秩合并
避免在并查集中使用递归find实现
使用快速输入方法（如scanf代替cin）

5.3 算法正确性验证

构造测试用例的技巧：

链式结构：1-2-3-...-n
- 预期结果：n/2
完全图：所有节点互连
- 预期结果：n-1
星型结构：中心节点连接所有其他节点
- 预期结果：1
二分图：均匀分成两组，组内无连接
- 预期结果：n/2-1

6. 算法扩展与变式思考

6.1 动态版本问题

如果题目改为在线查询（动态添加/删除边）：

可以使用Link-Cut Tree等动态树结构
或者分块处理+定期重构

6.2 加权版本

每个节点有重要性权重，要求删除后剩余网络的最大加权连通块不超过总权重的一半：

需要维护加权并查集
贪心策略可能需要调整

6.3 多目标优化

同时考虑最小化打击次数和最大化打击团伙的总价值：

转化为背包问题与图论的结合
可能需要使用启发式算法

7. 竞赛中的应用技巧

逆向思维训练：很多图论问题正向处理困难时，考虑逆向过程
并查集模板准备：比赛前准备好优化版的并查集实现
问题转化能力：将"删除节点"转化为"逐步添加节点"
提前终止优化：一旦满足条件立即输出结果，避免冗余计算

在实际比赛中遇到类似题目时，建议按照以下步骤分析：

明确题目要求的最终条件
分析正向操作的困难点
考虑是否存在逆向处理的可能性
选择合适的数据结构维护动态关系
设计提前终止的条件判断