【Leetcode】200. Number of Islands

题目地址：

https://leetcode.com/problems/number-of-islands/

给定一个二维矩阵，只含$0$和$1$。连成一片$1$可以看成一个岛屿。问一共多少个岛屿。可以设一个布尔visited数组，一旦在grid里找到了$1$，就用DFS将和这个$1$连成一片的位置都标记为true，并统计岛屿个数加一。遍历完grid后返回岛屿个数即可。代码如下：

public class Solution {
    public int numIslands(char[][] grid) {
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return 0;
        }
        
        int m = grid.length, n = grid[0].length;
        boolean[][] visited = new boolean[m][n];
        // 表示搜索的四个方向
        int[][] d = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
        
        int res = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
            	// 如果找到了一个新的没被访问过的岛屿的边界，就统计岛屿数量加一，并去拓展它
                if (grid[i][j] == '1' && !visited[i][j]) {
                    res++;
                    dfs(grid, i, j, visited, d);
                }
            }
        }
        
        return res;
    }
    // 从(i, j)开始，搜索与(i, j)连成一片的岛屿，并全部标记为true，表示搜索过了
    private void dfs(char[][] grid, int i, int j, boolean[][] visited, int[][] d) {
    	// 先标记(i, j)为true
        visited[i][j] = true;
        
        for (int k = 0; k < 4; k++) {
        	// 分别对四个方向进行DFS搜索，(x,y)表示下一层搜索的起点
            int x = i + d[k][0];
            int y = j + d[k][1];
            // 如果下一步没出界，并且也是岛屿的一部分，并且没访问过（防止回头搜索），就进行下一层搜索
            if (x >= 0 && x < grid.length && y >= 0 && y < grid[0].length
                    && !visited[x][y] && grid[x][y] == '1') {
                dfs(grid, x, y, visited, d);
            }
        }
    }
}

时空复杂度$O(mn)$。

C++：

class Solution {
 public:
  using vvc = vector<vector<char>>;
  int d[5] = {-1, 0, 1, 0, -1};
  int numIslands(vvc& g) {
    int res = 0;
    for (int i = 0; i < g.size(); i++)
      for (int j = 0; j < g[0].size(); j++) {
        if (g[i][j] == '1') {
          dfs(i, j, g);
          res++;
        }
      }

    return res;
  }

  void dfs(int x, int y, vvc& g) {
    g[x][y] = '0';
    for (int k = 0; k < 4; k++) {
      int nx = x + d[k], ny = y + d[k + 1];
      if (0 <= nx && nx < g.size() && 0 <= ny && ny < g[0].size() && g[nx][ny] == '1') {
        dfs(nx, ny, g);
      }
    }
  }
};

时空复杂度一样。