[LeetCode] 200. Number of Islands

Given an m x n 2d grid map of '1's (land) and '0's (water), return the number of islands.

An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.

Example 1:

Input: grid = [
  ["1","1","1","1","0"],
  ["1","1","0","1","0"],
  ["1","1","0","0","0"],
  ["0","0","0","0","0"]
]
Output: 1

Example 2:

Input: grid = [
  ["1","1","0","0","0"],
  ["1","1","0","0","0"],
  ["0","0","1","0","0"],
  ["0","0","0","1","1"]
]
Output: 3

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 300
• grid[i][j] is '0' or '1'.

岛屿数量。

给定一个由 '1'（陆地）和 '0'（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。

这一类flood fill的题的做法无非就是BFS和DFS。两种做法都要会。

BFS

时间O(mn)

空间O(mn)

Java实现

class Solution {
    int rows;
    int cols;

    public int numIslands(char[][] grid) {
        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') {
                    bfs(grid, i, j);
                    count++;
                }
            }
        }
        return count;
    }

    private void bfs(char[][] grid, int x, int y) {
        grid[x][y] = '0';
        int rows = grid.length;
        int cols = grid[0].length;
        Queue<Integer> queue = new LinkedList<>();
        int code = x * cols + y;
        queue.offer(code);
        while (!queue.isEmpty()) {
            code = queue.poll();
            int i = code / cols;
            int j = code % cols;
            if (i > 0 && grid[i - 1][j] == '1') {
                queue.offer((i - 1) * cols + j);
                grid[i - 1][j] = '0';
            }
            if (i < rows - 1 && grid[i + 1][j] == '1') {
                queue.offer((i + 1) * cols + j);
                grid[i + 1][j] = '0';
            }
            if (j > 0 && grid[i][j - 1] == '1') {
                queue.offer((i * cols) + j - 1);
                grid[i][j - 1] = '0';
            }
            if (j < cols - 1 && grid[i][j + 1] == '1') {
                queue.offer((i * cols) + j + 1);
                grid[i][j + 1] = '0';
            }
        }
    }
}

另一种Java实现，queue直接就是记录坐标，不需要convert成一个code

class Solution {
    public int numIslands(char[][] grid) {
        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') {
                    count++;
                    bfs(grid, i, j);
                }
            }
        }
        return count;
    }

    private void bfs(char[][] grid, int i, int j) {
        grid[i][j] = '0';
        int rows = grid.length;
        int cols = grid[0].length;
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[] { i, j });
        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            i = cur[0];
            j = cur[1];
            if (i > 0 && grid[i - 1][j] == '1') {
                queue.offer(new int[] { i - 1, j });
                grid[i - 1][j] = '0';
            }
            if (j > 0 && grid[i][j - 1] == '1') {
                queue.offer(new int[] { i, j - 1 });
                grid[i][j - 1] = '0';
            }
            if (i < rows - 1 && grid[i + 1][j] == '1') {
                queue.offer(new int[] { i + 1, j });
                grid[i + 1][j] = '0';
            }
            if (j < cols - 1 && grid[i][j + 1] == '1') {
                queue.offer(new int[] { i, j + 1 });
                grid[i][j + 1] = '0';
            }
        }
    }
}

JavaScript实现

/**
 * @param {character[][]} grid
 * @return {number}
 */
var numIslands = function(grid) {
    let res = 0;

    var bfs = function(grid, x, y) {
        grid[x][y] = '0';
        let rows = grid.length;
        let cols = grid[0].length;
        let queue = [];
        let code = x * cols + y;
        queue.push(code);
        while (queue.length) {
            code = queue.shift();
            let i = parseInt(code / cols);
            let j = code % cols;
            if (i > 0 && grid[i - 1][j] == '1') {
                queue.push((i - 1) * cols + j);
                grid[i - 1][j] = '0';
            }
            if (i < rows - 1 && grid[i + 1][j] == '1') {
                queue.push((i + 1) * cols + j);
                grid[i + 1][j] = '0';
            }
            if (j > 0 && grid[i][j - 1] == '1') {
                queue.push(i * cols + j - 1);
                grid[i][j - 1] = '0';
            }
            if (j < cols - 1 && grid[i][j + 1] == '1') {
                queue.push(i * cols + j + 1);
                grid[i][j + 1] = '0';
            }
        }
    };

    for (let i = 0; i < grid.length; i++) {
        for (let j = 0; j < grid[0].length; j++) {
            if (grid[i][j] === '1') {
                bfs(grid, i, j);
                res++;
            }
        }
    }
    return res;
};

DFS

时间O(mn)

空间O(n)

Java实现

class Solution {
    private int rows;
    private int cols;

    public int numIslands(char[][] grid) {
        int count = 0;
        rows = grid.length;
        if (rows == 0) {
            return 0;
        }
        cols = grid[0].length;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; 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 >= rows || j >= cols || grid[i][j] != '1') {
            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);
    }
}

JavaScript实现

/**
 * @param {character[][]} grid
 * @return {number}
 */
var numIslands = function(grid) {
    let res = 0;
    let rows = grid.length;
    if (rows == 0) return 0;
    let cols = grid[0].length;

    var dfs = function(grid, i, j) {
        if (i < 0 || j < 0 || i >= rows || j >= cols || grid[i][j] == '0') {
            return;
        }
        grid[i][j] = '0';
        dfs(grid, i, j + 1);
        dfs(grid, i, j - 1);
        dfs(grid, i - 1, j);
        dfs(grid, i + 1, j);
    };

    for (let i = 0; i < rows; i++) {
        for (let j = 0; j < cols; j++) {
            if (grid[i][j] == '1') {
                dfs(grid, i, j);
                res++;
            }
        }
    }
    return res;
};

flood fill题型总结

LeetCode 题目总结