蓝桥杯剪邮票真题解析：如何用DFS+排列组合高效解题（附完整代码）

蓝桥杯“剪邮票”难题的降维打击：从暴力枚举到连通性判定的思维跃迁

如果你正在备战蓝桥杯，尤其是被那些看似简单、实则暗藏玄机的“填空题”所困扰，那么“剪邮票”这道题很可能就是你算法思维进阶路上的一块试金石。它表面上是一个简单的组合选取问题，但内核却巧妙地融合了排列组合、深度优先搜索（DFS）以及二维平面上的连通性判定。很多初学者第一次接触时，会不自觉地陷入“如何生成所有5个格子的组合”以及“如何判断它们是否连通”这两个泥潭中，写出的代码要么冗长低效，要么逻辑漏洞百出。

今天，我们不打算照本宣科地复述一种解法，而是想和你一起，像侦探破案一样，层层剥开这道题目的外壳，探索多种解题路径的思维过程。你会发现，掌握一道经典赛题的精髓，远不止于背下一个AC代码，更在于理解其背后的问题转化艺术和算法工具的选择逻辑。我们将从最直观的暴力思路开始，逐步引导至高效优雅的解法，并深入探讨其中的细节陷阱和性能优化空间，目标是让你下次遇到类似“在网格中选取特定数量连通块”的问题时，能拥有清晰的解决框架。

1. 问题重述与核心难点剖析

题目描述很简单：一个3行4列的网格，共有12个格子，代表12张邮票。我们需要从中剪下恰好5张邮票，并且这5张邮票在网格上必须是连通的（仅考虑上下左右四个方向，对角线接触不算连通）。最终需要输出所有不同的剪取方法总数。

那么，难点究竟在哪里？

1. 组合爆炸：从12个格子中选5个，单纯的组合数 C(12,5) = 792 种。这个数量级对于计算机来说看似不大，但关键在于我们需要对每一种选法进行连通性判断。如果连通性判断算法效率低下，792次判断也可能成为瓶颈。
2. 连通性判定：这是本题的核心算法考点。给定一个由0和1组成的二维矩阵（1代表选中），如何高效判断所有“1”是否构成一个连通块？这需要用到图论中的遍历算法。
3. 去重：不同的选取顺序可能对应同一种形状的邮票组合。我们的计数方法必须确保每种形状只被计算一次，而不是每种“选择顺序”都被计算。

很多同学的第一个直觉是：“我直接生成所有5个格子的组合，然后对每个组合跑一遍BFS或DFS检查连通不就行了？”这个思路方向是对的，但如何“生成所有组合”以及“如何高效检查”，里面就有不少门道了。我们首先来看看这个最直接的思路如何实现，以及它可能遇到的问题。

2. 暴力枚举的起点：生成所有组合

我们用一个长度为12的一维数组 a 来表示选择状态，其中5个位置为1（选中），7个位置为0（未选中）。生成所有这样的数组，本质上就是生成所有包含5个1和7个0的排列。

这里第一个技巧就出现了：我们需要的不是所有排列（12!），而是所有组合的模式。因为 [1,1,1,1,1,0,0,0,0,0,0,0] 和 [1,1,1,1,0,1,0,0,0,0,0,0] 如果只是1和0的位置不同，但对应的选中格子集合是相同的，那么它们就是同一种组合。直接生成排列会产生大量重复。

C++的STL库提供了一个神器：std::next_permutation。它的一个美妙特性在于，当对已排序的序列进行全排列时，它生成的是无重复的字典序排列。我们可以利用这个特性来生成所有组合模式。

int a[12] = {0,0,0,0,0,0,0,1,1,1,1,1}; // 初始状态，7个0在前，5个1在后
do {
    // 对当前排列a进行连通性判断
    if (is_connected(a)) {
        ans++;
    }
} while (std::next_permutation(a, a+12));

为什么这样可行？初始数组是排序好的（所有0在1之前）。next_permutation 会遍历这个序列所有不同的排列。由于0和0之间、1和1之间是不可区分的，所以它遍历的每一种排列，都唯一对应了一种5个格子的选择方案（即1所在的下标集合）。这样就完美解决了生成无重复组合的问题。

注意：这里的关键是初始数组必须排序。如果初始数组是乱序的，next_permutation 仍然会生成所有排列，但可能会跳过一些字典序更小的排列，导致漏解。

生成了组合之后，我们接下来就要面对核心挑战：is_connected 函数如何实现？

3. 连通性判定的艺术：DFS/BFS的巧妙应用

连通性判定是一个经典的图遍历问题。我们可以把选中的5个格子看作图中的节点，如果两个选中格子上下左右相邻，则认为它们之间有一条边。问题转化为：判断这个图是否是一个连通图。

一个非常直接的想法是：先找到任意一个被选中的格子作为起点，然后从这个起点出发，进行深度优先搜索（DFS）或广度优先搜索（BFS），遍历所有与其连通的选中格子。遍历结束后，检查是否所有被选中的格子都被访问过。如果是，则说明整个图是连通的。

具体步骤拆解：

1. 二维化：将一维数组 a 映射回3x4的二维网格 grid 中，便于进行上下左右的邻居访问。
2. 寻找起点：遍历网格，找到第一个值为1的格子，作为DFS/BFS的起点 (start_x, start_y)。
3. 执行遍历：从起点开始，向四个方向（上、下、左、右）递归或迭代地探索。探索的条件是：坐标合法，并且该格子值为1（选中且未被访问过）。访问过的格子需要做标记（例如将其值设为0或一个特殊的访问标记），避免重复访问。
4. 验证结果：遍历结束后，再次扫描整个网格。如果还存在值为1的格子，说明有些选中格子无法从起点到达，即整个选择是不连通的。反之，则连通。

让我们用DFS来实现这个逻辑，并注意一些细节：

// 方向数组，方便遍历四个邻居
int dirs[4][2] = {{1,0}, {-1,0}, {0,1}, {0,-1}};

bool is_connected(int a[12]) {
    int grid[3][4];
    int start_x = -1, start_y = -1;
    int k = 0;
    
    // 步骤1: 二维化并寻找起点
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            grid[i][j] = a[k];
            if (grid[i][j] == 1 && start_x == -1) { // 找到第一个1作为起点
                start_x = i;
                start_y = j;
            }
            k++;
        }
    }
    
    // 如果没找到5个1（理论上不会），或者起点没找到，直接返回false
    if (start_x == -1) return false;
    
    // 步骤2: DFS遍历
    // 注意：为了不破坏原始数据，这里使用一个单独的visited数组或直接修改grid副本
    // 我们选择修改grid，将访问过的1置为0
    std::function<void(int, int)> dfs = [&](int x, int y) {
        if (x < 0 || x >= 3 || y < 0 || y >= 4) return; // 越界
        if (grid[x][y] != 1) return; // 不是未访问的选中格子
        
        grid[x][y] = 0; // 标记为已访问
        for (auto &d : dirs) {
            dfs(x + d[0], y + d[1]); // 递归探索四个方向
        }
    };
    
    dfs(start_x, start_y);
    
    // 步骤3: 验证是否所有1都被访问（即被置为0）
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            if (grid[i][j] == 1) { // 还有未被访问的1
                return false;
            }
        }
    }
    return true;
}

这个DFS版本清晰易懂，但有一个极其重要的细节：递归深度。网格只有12个格子，选中5个，递归深度最大为5，所以完全不用担心栈溢出问题。这是DFS在此类小规模网格问题上的优势。

4. 思维跃迁：并查集——另一种连通性判定的视角

除了DFS/BFS，并查集（Union-Find） 是处理连通性问题的另一把利器。它的思想更适合“动态连接”的场景，但用于静态判定也同样高效，且代码别具一格。

思路是这样的：我们仍然遍历所有792种组合。对于每一种组合，我们初始化一个并查集，每个选中的格子自成一个集合。然后，我们遍历所有选中的格子，对于每个格子，检查其右方和下方的邻居是否也被选中。如果选中，就将当前格子与这个邻居在并查集中合并。遍历结束后，检查所有选中格子是否属于同一个集合。如果是，则说明它们连通。

为什么只检查右方和下方？因为对于每个格子，我们检查它的右邻居和下邻居，就等价于检查了所有格子与其左邻居和上邻居的关系（避免重复检查）。这是一种常见的优化遍历手段。

class UnionFind {
private:
    vector<int> parent;
public:
    UnionFind(int n) : parent(n) {
        for (int i = 0; i < n; i++) parent[i] = i;
    }
    int find(int x) {
        if (parent[x] != x) {
            parent[x] = find(parent[x]); // 路径压缩
        }
        return parent[x];
    }
    void unite(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        if (rootX != rootY) {
            parent[rootY] = rootX;
        }
    }
    bool isConnected(int x, int y) {
        return find(x) == find(y);
    }
};

bool is_connected_unionfind(int a[12]) {
    // 将二维坐标映射为一维索引: index = i * 4 + j
    vector<int> selected;
    for (int idx = 0; idx < 12; idx++) {
        if (a[idx] == 1) {
            selected.push_back(idx);
        }
    }
    
    UnionFind uf(12); // 虽然只有5个选中，但并查集大小设为12更方便映射
    
    // 遍历所有选中的格子
    for (int idx : selected) {
        int i = idx / 4;
        int j = idx % 4;
        // 检查右邻居
        if (j + 1 < 4) {
            int right_idx = idx + 1;
            if (a[right_idx] == 1) {
                uf.unite(idx, right_idx);
            }
        }
        // 检查下邻居
        if (i + 1 < 3) {
            int down_idx = idx + 4;
            if (a[down_idx] == 1) {
                uf.unite(idx, down_idx);
            }
        }
    }
    
    // 判断所有选中格子是否在同一个集合
    int root = uf.find(selected[0]);
    for (int idx : selected) {
        if (uf.find(idx) != root) {
            return false;
        }
    }
    return true;
}

并查集方法的优势在于，其时间复杂度近乎常数，对于连通性判定非常快。虽然在本题小数据量下优势不明显，但它提供了一种不同的思维模型，对于理解连通性问题本质很有帮助。

判定方法	核心思想	优点	缺点	适用场景
DFS/BFS	从一点出发，遍历所有可达点。	代码直观，易于理解和实现。	递归深度需注意（本题无碍）。	通用性强，尤其适合路径、连通块计数等问题。
并查集	逐步合并相邻元素，最后检查根节点。	合并与查询效率高，适合动态连通场景。	代码相对复杂，需要额外数据结构。	需要多次动态连接/查询连通性的场景。

5. 性能优化与剪枝思考

尽管792种组合的枚举看起来已经是最优解（因为我们必须检查每一种可能的5格子组合），但在算法竞赛中，我们总是可以思考：有没有办法提前排除一些明显无效的组合，减少 is_connected 的调用次数？

这就是剪枝的思想。虽然对于本题，792次判断已经足够快（能在毫秒级完成），但掌握剪枝思维对解决更复杂的问题至关重要。

一个可能的剪枝思路是：连通块的数量必须为1。我们可以在DFS/BFS或并查集判定的过程中，一旦发现不连通就立刻返回 false，这本身就是一种剪枝。但有没有更前置的剪枝？

考虑一个极端情况：如果选中的5个格子都分布在网格的四个角，它们有可能连通吗？有可能，但路径非常特定。一个更通用的启发式规则是：选中的格子必须构成一个“凸”的形状，或者至少不能有“孤立”的格子。但用代码形式化这个规则比较困难。

另一种思路是基于搜索顺序的剪枝。我们在生成组合时，如果采用回溯法而非 next_permutation，可以在构造组合的过程中就进行连通性检查。例如，当我们已经选择了3个格子，如果这3个格子已经构成了两个互不连通的组件，那么无论后面再选哪2个格子，都无法使5个格子连通（因为添加的格子最多只能连接到一个组件）。这样就可以提前终止当前分支的搜索。

下面是一个回溯+DFS剪枝的思路框架（非完整代码，仅展示思想）：

int grid[3][4] = {0};
int ans = 0;
int selected = 0;

void backtrack(int pos) { // pos: 当前考虑到的格子编号（0-11）
    if (selected == 5) {
        // 检查连通性
        if (is_connected_grid()) ans++;
        return;
    }
    if (pos == 12) return; // 没格子可选了
    
    // 剪枝：如果剩下的格子数 + 已选数 < 5，不可能凑够，直接返回
    if (selected + (12 - pos) < 5) return;
    
    // 剪枝（高级）：如果已选格子已经形成多个连通分量，且剩余选择无法将其连接...
    // 这里需要实现一个函数来判断当前已选格子的连通分量数，实现较复杂，略。
    
    // 选择当前格子
    int i = pos / 4, j = pos % 4;
    grid[i][j] = 1;
    selected++;
    backtrack(pos + 1);
    
    // 不选择当前格子
    grid[i][j] = 0;
    selected--;
    backtrack(pos + 1);
}

这种回溯加剪枝的方法在组合数很大时优势明显，但对于本题，其代码复杂度远高于 next_permutation + 连通性判定的简洁组合。因此，在竞赛中，选择哪种方法往往取决于在代码复杂度和运行效率之间取得平衡。

6. 代码整合与最终答案

将我们讨论的最清晰、最简洁的方法组合起来：使用 next_permutation 生成所有无重复组合，使用DFS进行连通性判定。下面是完整的C++实现：

#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;

int dirs[4][2] = {{1,0}, {-1,0}, {0,1}, {0,-1}};

bool is_connected(int a[12]) {
    int grid[3][4];
    int start_x = -1, start_y = -1;
    int k = 0;
    
    // 映射到二维网格并找起点
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            grid[i][j] = a[k];
            if (grid[i][j] == 1 && start_x == -1) {
                start_x = i;
                start_y = j;
            }
            k++;
        }
    }
    
    // DFS遍历函数
    function<void(int, int)> dfs = [&](int x, int y) {
        if (x < 0 || x >= 3 || y < 0 || y >= 4) return;
        if (grid[x][y] != 1) return;
        grid[x][y] = 0; // 访问标记
        for (auto &d : dirs) {
            dfs(x + d[0], y + d[1]);
        }
    };
    
    dfs(start_x, start_y);
    
    // 检查是否还有未访问的1
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            if (grid[i][j] == 1) {
                return false;
            }
        }
    }
    return true;
}

int main() {
    int a[12] = {0,0,0,0,0,0,0,1,1,1,1,1}; // 初始状态，0在前，1在后
    int ans = 0;
    
    do {
        if (is_connected(a)) {
            ans++;
        }
    } while (next_permutation(a, a+12));
    
    cout << ans << endl;
    return 0;
}

运行这段代码，你会得到最终的答案：116。

这个数字就是所有不同的、连通的5张邮票剪取方法。你可以尝试手动验证一些简单情况来增强理解，比如所有5张邮票排成一条直线（横或竖）有多少种，排成一个“十”字形有多少种，但最终验证还是交给程序最可靠。

7. 举一反三：问题变体与思维扩展

掌握“剪邮票”的核心解法后，我们可以尝试挑战一些变体问题，这能极大地锻炼你的算法迁移能力。

变体1：剪下k张邮票 如果问题不是剪5张，而是剪k张（1 ≤ k ≤ 12），方法数是多少？这时，组合数会急剧增大（C(12, k)），但我们的算法框架依然适用。只需要修改初始数组 a 中1的个数即可。你可以尝试计算k从1到12的所有结果，会发现它满足一个先增后减的对称分布。

变体2：更大的网格 如果网格不是3x4，而是m x n，要剪下t个连通的格子。这时，组合数 C(m*n, t) 可能变得非常大，暴力枚举所有组合可能超时。这就需要用到更高级的搜索技巧，比如之前提到的回溯剪枝，或者状态压缩DP。这是算法竞赛中一个常见的难题方向。

变体3：计算所有连通形状 题目只要求计数，但如果要求输出所有具体的连通形状（用坐标表示），该如何修改代码？你需要在 is_connected 函数返回 true 时，将当前选中的格子坐标保存下来。注意去重，因为不同的排列可能对应同一种形状。一个去重的好方法是将选中的坐标集合进行标准化（例如排序后转换成字符串），存入 set 中。

思维扩展：从“剪邮票”到“岛屿问题” LeetCode上有大量基于网格的DFS/BFS问题，例如“岛屿数量”、“岛屿的最大面积”、“被围绕的区域”等。“剪邮票”可以看作是“寻找所有大小为k的连通岛屿”问题的一个特例。理解了这个问题的解法，再去看那些题目，你会觉得思路非常顺畅。它们的核心都是：

1. 遍历网格。
2. 找到一个符合条件（如值为‘1’）的起点。
3. 从这个起点开始DFS/BFS，标记所有连通的点。
4. 根据题目要求进行计数、面积计算或修改操作。

最后，记得在竞赛中，像“剪邮票”这类填空题，最终只需要提交一个数字答案。但它的价值远不止于此。它像一把钥匙，为你打开了一类问题的解决思路：如何将组合选取问题与图连通性判定结合起来。下次当你看到“在矩阵中选取若干个满足特定条件的格子”时，不妨想想今天讨论的生成、映射、遍历、判定的四步法，或许就能豁然开朗。