网格遍历算法：从DFS/BFS到并查集的实战解析

1. 题目背景与需求分析

2026年小米春招的这道编程题考察的是典型的网格遍历问题，属于算法面试中的高频考点。题目描述虽然未给出完整内容，但从"农田网格"这个关键词可以推断，这很可能是一个与矩阵遍历、连通区域统计相关的问题。

这类题目在实际工作中有着广泛的应用场景：

• 游戏开发中的地图区域划分
• 图像处理中的连通区域标记
• 农业科技中的耕地区块分析
• 物联网设备网格化管理

2. 问题建模与算法选择

2.1 题目可能的变体分析

根据常见的"农田网格"类题目，我们推测可能有以下几种变体：

1. 统计独立农田区块数量（岛屿问题）
2. 计算最大农田面积（最大连通区域）
3. 农田灌溉路径规划（最短路径问题）
4. 农田产量统计（带权网格遍历）

2.2 算法选择策略

针对不同变体，我们需要选择相应的算法：

3. 核心解法实现

3.1 Java实现（以岛屿问题为例）

java复制class Solution {
    private int[][] directions = {{0,1},{1,0},{0,-1},{-1,0}};
    
    public int countFarmlands(char[][] grid) {
        if(grid == null || grid.length == 0) return 0;
        
        int count = 0;
        for(int i=0; i<grid.length; i++){
            for(int j=0; j<grid[0].length; j++){
                if(grid[i][j] == '1'){
                    dfs(grid, i, j);
                    count++;
                }
            }
        }
        return count;
    }
    
    private void dfs(char[][] grid, int i, int j){
        if(i<0 || j<0 || i>=grid.length || j>=grid[0].length || grid[i][j]!='1') 
            return;
        
        grid[i][j] = '0'; // 标记为已访问
        for(int[] dir : directions){
            dfs(grid, i+dir[0], j+dir[1]);
        }
    }
}

3.2 C++优化实现

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

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        if(grid.empty()) return 0;
        
        int m = grid.size(), n = grid[0].size();
        int islands = 0;
        
        for(int i=0; i<m; ++i){
            for(int j=0; j<n; ++j){
                if(grid[i][j] == '1'){
                    ++islands;
                    bfs(grid, i, j);
                }
            }
        }
        return islands;
    }
    
private:
    void bfs(vector<vector<char>>& grid, int x, int y){
        queue<pair<int,int>> q;
        q.push({x,y});
        grid[x][y] = '0';
        
        int dirs[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};
        
        while(!q.empty()){
            auto curr = q.front(); q.pop();
            for(auto dir : dirs){
                int nx = curr.first + dir[0];
                int ny = curr.second + dir[1];
                if(nx>=0 && nx<grid.size() && ny>=0 && ny<grid[0].size() && grid[nx][ny]=='1'){
                    grid[nx][ny] = '0';
                    q.push({nx,ny});
                }
            }
        }
    }
};

3.3 Python简洁实现

python复制def numIslands(grid):
    if not grid:
        return 0
    
    count = 0
    for i in range(len(grid)):
        for j in range(len(grid[0])):
            if grid[i][j] == '1':
                dfs(grid, i, j)
                count += 1
    return count

def dfs(grid, i, j):
    if i<0 or j<0 or i>=len(grid) or j>=len(grid[0]) or grid[i][j] != '1':
        return
    grid[i][j] = '#'
    dfs(grid, i+1, j)
    dfs(grid, i-1, j)
    dfs(grid, i, j+1)
    dfs(grid, i, j-1)

4. 算法优化与进阶

4.1 并查集解法

对于大规模网格数据，可以考虑使用并查集(Union-Find)数据结构：

java复制class UnionFind {
    int[] parent;
    int count;
    
    public UnionFind(char[][] grid) {
        int m = grid.length, n = grid[0].length;
        parent = new int[m*n];
        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                if(grid[i][j] == '1'){
                    int id = i*n + j;
                    parent[id] = id;
                    count++;
                }
            }
        }
    }
    
    public int find(int x){
        while(parent[x] != x){
            parent[x] = parent[parent[x]]; // 路径压缩
            x = parent[x];
        }
        return x;
    }
    
    public void union(int x, int y){
        int rootX = find(x);
        int rootY = find(y);
        if(rootX != rootY){
            parent[rootX] = rootY;
            count--;
        }
    }
}

class Solution {
    public int numIslands(char[][] grid) {
        if(grid == null || grid.length == 0) return 0;
        
        int m = grid.length, n = grid[0].length;
        UnionFind uf = new UnionFind(grid);
        
        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                if(grid[i][j] == '1'){
                    if(i>0 && grid[i-1][j]=='1') 
                        uf.union(i*n+j, (i-1)*n+j);
                    if(j>0 && grid[i][j-1]=='1')
                        uf.union(i*n+j, i*n+j-1);
                }
            }
        }
        return uf.count;
    }
}

4.2 性能对比分析

不同解法在LeetCode测试数据集上的表现：

注意：实际选择时需要考虑网格大小和语言特性。Python中DFS可能因递归深度限制而不适合超大网格。

5. 边界条件与测试用例

5.1 必须考虑的边界情况

1. 空网格输入
2. 全0网格
3. 全1网格
4. 锯齿状网格（非矩形）
5. 超大网格（内存优化）
6. 单个单元格网格

5.2 测试用例设计示例

python复制test_cases = [
    ([], 0), # 空输入
    ([["0","0"],["0","0"]], 0), # 无农田
    ([["1","1"],["1","1"]], 1), # 全农田
    ([["1","0"],["0","1"]], 2), # 对角线农田
    ([["1","1","0"],["0","0","1"],["1","0","1"]], 3) # 复杂分布
]

6. 面试技巧与实战建议

6.1 面试回答策略

1. 先明确问题要求和边界条件
2. 讨论可能的算法方案和trade-off
3. 选择最合适的实现方式
4. 逐步编码并解释思路
5. 主动提出测试用例

6.2 常见错误规避

1. 忘记标记已访问节点导致无限循环
2. 数组越界检查不完整
3. 未处理空输入等边界情况
4. 递归深度过大导致栈溢出
5. 变量命名混乱影响可读性

6.3 复杂度分析要点

在面试中需要明确说明：

• 时间复杂度：每个节点被访问一次，O(M×N)
• 空间复杂度：
  • DFS最坏情况O(M×N)（递归栈）
  • BFS通常O(min(M,N))（队列大小）
  • 并查集O(M×N)（存储父节点）

7. 扩展应用与变种题目

7.1 实际工程应用

1. 图像处理中的连通组件标记
2. 社交网络中的好友圈识别
3. 电路板中的短路区域检测
4. 游戏中的地图区域生成

7.2 推荐练习题目

1. 岛屿的最大面积（LeetCode 695）
2. 被围绕的区域（LeetCode 130）
3. 统计子岛屿（LeetCode 1905）
4. 岛屿周长（LeetCode 463）
5. 最大人工岛（LeetCode 827）

7.3 高级变种思路

1. 并行算法处理超大网格
2. 持久化存储中的增量计算
3. 动态网格的实时更新
4. 三维网格的扩展应用

在准备此类算法题时，建议从基础DFS/BFS实现开始，逐步掌握Union-Find等高级数据结构，最后思考如何优化空间使用和并行计算。实际面试中，清晰的思路表达和完整的边界考虑往往比完美的代码更重要。