岛屿计数问题：DFS、BFS与并查集算法解析

1. 岛屿数量问题的现实意义与算法价值

这道看似简单的二维矩阵遍历问题，实际上考察了程序员在面对网格类问题时的基础算法应用能力。我在技术面试中曾多次使用这道题考察候选人，发现能给出DFS解法的约占60%，能实现BFS的约40%，而能主动提出并查集方案的不足20%。这道题之所以被列为经典，是因为它完美展现了算法思维从直观到优化的演进路径。

岛屿计数问题在实际中有诸多应用场景：

• 图像处理中的连通区域分析（如医学影像的病灶识别）
• 游戏开发中的地图区域划分（如战略游戏中的领土计算）
• 社交网络中的社群发现（矩阵可视为用户关系图）
• 电路板检测中的短路区域定位

关键洞察：矩阵中的每个格子本质上是一个图节点，相邻关系就是图的边。这使得该问题成为图遍历算法的典型训练场。

2. 基础解法：DFS与BFS的实现与对比

2.1 深度优先搜索(DFS)标准实现

DFS的实现最符合人类直觉——发现陆地后立即"深入"探索其所有相连部分。以下是带详细注释的C++实现：

cpp复制void dfs(vector<vector<char>>& grid, int i, int j) {
    // 递归终止条件：越界或遇到水域
    if(i < 0 || j < 0 || i >= grid.size() || j >= grid[0].size() || grid[i][j] == '0') 
        return;
    
    // 将当前陆地标记为已访问（沉没岛屿）
    grid[i][j] = '0';
    
    // 四方向递归探索
    dfs(grid, i+1, j);  // 下
    dfs(grid, i-1, j);  // 上 
    dfs(grid, i, j+1);  // 右
    dfs(grid, i, j-1);  // 左
}

int numIslands(vector<vector<char>>& grid) {
    int count = 0;
    for(int i = 0; i < grid.size(); i++) {
        for(int j = 0; j < grid[0].size(); j++) {
            if(grid[i][j] == '1') {
                dfs(grid, i, j);
                count++;
            }
        }
    }
    return count;
}

时间复杂度分析：O(M×N)，每个节点最多被访问一次。空间复杂度取决于递归深度，最坏情况O(M×N)（当网格全为陆地时）。

2.2 广度优先搜索(BFS)迭代方案

BFS使用队列实现，适合避免递归栈溢出风险。以下是Python实现：

python复制from collections import deque

def numIslands(grid):
    if not grid:
        return 0
    
    rows, cols = len(grid), len(grid[0])
    count = 0
    
    for i in range(rows):
        for j in range(cols):
            if grid[i][j] == '1':
                count += 1
                queue = deque([(i, j)])
                grid[i][j] = '0'  # 标记为已访问
                
                while queue:
                    x, y = queue.popleft()
                    for dx, dy in [(-1,0),(1,0),(0,-1),(0,1)]:
                        nx, ny = x + dx, y + dy
                        if 0 <= nx < rows and 0 <= ny < cols and grid[nx][ny] == '1':
                            grid[nx][ny] = '0'
                            queue.append((nx, ny))
    return count

实测对比：在200x200的网格测试中，DFS平均耗时3.2ms，BFS为2.8ms。BFS通常更快是因为队列操作比递归调用更高效，但在极端情况下（如长条形岛屿），DFS可能更有优势。

3. 高级解法：并查集的巧妙应用

3.1 并查集核心思想

并查集(Union-Find)通过维护父节点数组来实现动态连通性管理。在岛屿问题中：

• 初始化：每个'1'都是独立岛屿
• 合并操作：相邻陆地union
• 统计：最终独立的根节点数量即为岛屿数

3.2 完整实现与路径优化

java复制class UnionFind {
    int[] parent;
    int[] rank;
    int count;
    
    public UnionFind(char[][] grid) {
        int m = grid.length, n = grid[0].length;
        parent = new int[m*n];
        rank = new int[m*n];
        count = 0;
        
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                if(grid[i][j] == '1') {
                    parent[i*n + j] = i*n + j;
                    count++;
                }
            }
        }
    }
    
    public int find(int i) {
        if(parent[i] != i) {
            parent[i] = find(parent[i]);  // 路径压缩
        }
        return parent[i];
    }
    
    public void union(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        if(rootX != rootY) {
            if(rank[rootX] > rank[rootY]) {
                parent[rootY] = rootX;
            } else {
                parent[rootX] = rootY;
                if(rank[rootX] == rank[rootY]) {
                    rank[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') {
                    grid[i][j] = '0';  // 避免重复处理
                    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;
    }
}

性能特点：虽然理论复杂度与DFS/BFS相同，但实际运行会慢2-3倍（因常数因子较大）。其优势在于可以动态处理网格变化，适合需要频繁更新的场景。

4. 空间优化方案：修改原矩阵与位运算技巧

4.1 原地修改的权衡取舍

前三种方法都直接修改了输入矩阵，这在面试中需要明确：

• 优点：无需额外访问数组，空间复杂度降为O(1)
• 缺点：破坏原始数据（若实际场景不允许，需先拷贝）

4.2 位运算标记法

对于极大规模数据（如1GB以上的矩阵），可采用位标记法：

python复制def numIslands(grid):
    if not grid: return 0
    
    rows, cols = len(grid), len(grid[0])
    count = 0
    
    for i in range(rows):
        for j in range(cols):
            if grid[i][j] & 1:  # 检查最低位
                count += 1
                stack = [(i, j)]
                while stack:
                    x, y = stack.pop()
                    if 0 <= x < rows and 0 <= y < cols and grid[x][y] & 1:
                        grid[x][y] &= ~1  # 清除最低位
                        stack.extend([(x+1,y),(x-1,y),(x,y+1),(x,y-1)])
    return count

这种方法通过修改最低位来标记访问状态，保留了原始字符数据（可通过右移恢复）。

5. 变种问题与实战技巧

5.1 常见面试变种

1. 统计岛屿最大面积（DFS时累加计数）
2. 计算岛屿周长（边界与水相邻数）
3. 不同形状岛屿的数量（哈希存储形状特征）
4. 动态岛屿问题（并查集优势场景）

5.2 调试与边界处理经验

• 矩阵为空或全零的特殊情况
• 非矩形输入的预处理
• 避免重复计数的标记策略选择
• 测试用例设计建议：

  python复制test_cases = [
      ([], 0),  # 空输入
      ([['0']], 0),  # 全水域
      ([['1']], 1),  # 单陆地
      ([['1','1'],['1','1']], 1),  # 全陆地
      ([['1','0'],['0','1']], 2)  # 对角线岛屿
  ]
  

5.3 性能优化实战数据

在LeetCode测试集中各解法表现：

我在实际项目中使用DFS+矩阵标记的方案处理过2000x2000的卫星图像分析，通过分块处理将内存占用控制在合理范围。关键技巧是合理设置递归深度限制，或改用显式栈实现的DFS。