洛谷 P1162 填涂颜色 | DFS 解法详解

原创于 2025-11-07 06:00:00 发布 · 985 阅读

20 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#深度优先 #算法 #c++ #CSP-J/S

CSP-J/S高频考点突破专栏收录该内容

164 篇文章

订阅专栏

题目分析

问题描述

给定一个 n×n 的方阵（1 ≤ n ≤ 30），由数字 0 和 1 组成。其中 1 构成一个闭合圈，要求将闭合圈内的所有 0 替换为 2。闭合圈内的 0 定义为：从该 0 出发，只向上下左右四个方向移动且仅经过其他 0 的情况下，无法到达方阵的边界。

关键点

闭合圈可能为任意形状，不一定是环形
圈内的 0 是连通的（两两之间可以相互到达）
方阵内只有一个闭合圈，圈内至少有一个 0

算法思路

核心思想：逆向思维 + DFS

直接寻找闭合圈内部的 0 比较困难，因此采用逆向思维：

从边界开始 DFS，标记所有能够到达的 0（这些是闭合圈外部的 0）
剩下的未被标记的 0 就是闭合圈内部的 0，将这些 0 替换为 2

为什么选择 DFS？

代码简洁：递归实现更加直观
效率足够：n ≤ 30，DFS 的递归深度完全可接受
避免复杂判断：通过从边界开始搜索，自然区分内外区域

完整AC代码（DFS实现）

#include <iostream>
#include <cstring>
using namespace std;

const int MAXN = 35;  // 开大一些，包含边界
int grid[MAXN][MAXN]; // 存储网格数据
bool visited[MAXN][MAXN]; // 标记访问状态
int n;

// 方向数组：上、下、左、右
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};

// DFS搜索函数
void dfs(int x, int y) {
    // 边界检查：超出扩展后的网格范围
    if (x < 0 || x > n+1 || y < 0 || y > n+1) return;
    // 遇到1（围墙）或已访问过的点，返回
    if (grid[x][y] == 1 || visited[x][y]) return;
    
    visited[x][y] = true; // 标记为已访问
    
    // 向四个方向递归搜索
    for (int i = 0; i < 4; i++) {
        dfs(x + dx[i], y + dy[i]);
    }
}

int main() {
    cin >> n;
    
    // 初始化网格，周围加一圈0[6](@ref)
    memset(grid, 0, sizeof(grid));
    memset(visited, false, sizeof(visited));
    
    // 读取输入数据（实际网格范围为1~n）
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            cin >> grid[i][j];
        }
    }
    
    // 从(0,0)开始DFS，标记所有外部0[6](@ref)
    dfs(0, 0);
    
    // 输出结果
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (grid[i][j] == 1) {
                cout << "1 ";
            } else if (visited[i][j]) {
                // 被访问过的是外部0，输出0
                cout << "0 ";
            } else {
                // 未被访问的是内部0，输出2
                cout << "2 ";
            }
        }
        cout << endl;
    }
    
    return 0;
}

代码详解

1. 数据结构设计

const int MAXN = 35;  // 开大一些，包含边界
int grid[MAXN][MAXN]; // 存储网格数据
bool visited[MAXN][MAXN]; // 标记访问状态

网格扩展：将原始 n×n 网格扩展为 (n+2)×(n+2)，周围加一圈0
访问标记：记录每个点是否被DFS访问过

2. DFS搜索函数

void dfs(int x, int y) {
    if (x < 0 || x > n+1 || y < 0 || y > n+1) return;
    if (grid[x][y] == 1 || visited[x][y]) return;
    
    visited[x][y] = true;
    
    for (int i = 0; i < 4; i++) {
        dfs(x + dx[i], y + dy[i]);
    }
}

关键逻辑：

边界检查：确保不超出扩展后的网格范围
障碍判断：遇到1（围墙）则停止该方向搜索
递归标记：向四个方向继续深度搜索

3. 主函数逻辑

int main() {
    // 读取输入
    // 初始化网格和访问标记
    
    // 从(0,0)开始DFS
    dfs(0, 0);
    
    // 根据访问状态输出结果
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (grid[i][j] == 1) {
                cout << "1 ";
            } else if (visited[i][j]) {
                cout << "0 ";
            } else {
                cout << "2 ";
            }
        }
        cout << endl;
    }
}

关键技巧说明

1. 网格扩展技巧

在原始网格周围加一圈0：

memset(grid, 0, sizeof(grid)); // 周围自动初始化为0

目的：确保从(0,0)开始DFS能够覆盖所有边界情况，避免边缘的0被误判为内部点。

2. 逆向思维应用

不直接寻找内部点，而是：

标记外部点：从边界开始DFS标记所有可达的0
剩余即内部：未被标记的0自然就是闭合圈内部的点

3. 输出逻辑

if (grid[i][j] == 1) {
    cout << "1 ";      // 保持围墙不变
} else if (visited[i][j]) {
    cout << "0 ";      // 外部0保持不变
} else {
    cout << "2 ";      // 内部0改为2
}

测试用例验证

样例输入

6
0 0 0 0 0 0
0 0 1 1 1 1
0 1 1 0 0 1
1 1 0 0 0 1
1 0 0 0 0 1
1 1 1 1 1 1

正确输出

0 0 0 0 0 0
0 0 1 1 1 1
0 1 1 2 2 1
1 1 2 2 2 1
1 2 2 2 2 1
1 1 1 1 1 1

复杂度分析

时间复杂度

DFS遍历：每个节点最多被访问一次，O(n²)
总体复杂度：O(n²)，完全满足 n ≤ 30 的要求

空间复杂度

网格存储：O(n²)
递归栈：最坏情况 O(n²)，但 n ≤ 30 时可接受

常见错误与解决方法

1. 边界处理错误

错误现象：边缘的0被误判为内部点解决：使用网格扩展技巧，在周围加一圈0

2. 方向数组不完整

错误现象：部分连通区域未被正确标记解决：确保四个方向（上、下、左、右）齐全

3. 访问标记遗漏

错误现象：重复访问导致栈溢出或错误结果解决：在递归前正确标记访问状态

算法总结

本文提供的DFS解法通过了洛谷所有测试点，关键优势在于：

逆向思维：通过标记外部点来间接找到内部点
网格扩展：避免边界条件的复杂判断
代码简洁：DFS递归实现直观易懂
效率保证：在题目约束下完全可行

这种"从外向内"的标记思想可以应用于许多类似的连通性问题，如岛屿计数、区域填充等。

提示：如果遇到WA，请检查网格扩展是否正确实现，以及DFS的递归方向是否完整。

🔥 关注我，解锁CSP-J/S竞赛全攻略 🔥

（每日更新高频考点 + 精选真题解析，助你轻松备赛！）
👇 点击关注 → 立即提升竞赛战力 👇
[https://blog.csdn.net/stillwatersss]