LeetCode 1020. 飞地的数量题解

1020. 飞地的数量题解

题目来源：1020. 飞地的数量

2022.02.12每日一题

本题目是求出无法与边界的陆地的总数

法一：深搜

以边界的点进行搜索，搜索上下左右四个方向的格子，如果格子是陆地 (1)，就将其置为海洋 (0)，最后统计矩阵之中未被置成 0 的 1 的数量，即可得出正确答案

具体代码以及注释如下

class Solution {
public:
    // 设置矩阵的行和列
    int m, n;
    // 访问格子的四个方向的格子
    vector<vector<int>> dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

    int numEnclaves(vector<vector<int>> &grid) {
        m = grid.size(), n = grid[0].size();
        
        // 遍历矩阵的四周，进行遍历，如果是海洋(0)的话则会停止递归，反之则继续
        for (int i = 0; i < m; i++) {
            dfs(grid, i, 0);
            dfs(grid, i, n - 1);
        }
        for (int i = 0; i < n; i++) {
            dfs(grid, 0, i);
            dfs(grid, m - 1, i);
        }

        // 定义结果变量
        int res = 0;
        // 在递归结束以后，所有能和边界接触到的陆地都会被置为 0 
        // 因此只需要遍历矩阵之中剩余陆地(1)的数量就是最后的结果
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j]) {
                    res++;
                }
            }
        }
        return res;
    }

    // 进行递归操作
    void dfs(vector<vector<int>> &grid, int i, int j) {
        // 如果 grid[i][j] 不在范围或者是海洋，就停止递归
        if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] == 0) {
            return;
        }
        // 将陆地置为海洋
        grid[i][j] = 0;
        // 遍历周围的四个方向的格子，继续进行递归操作
        for (vector<int> dir: dirs) {
            dfs(grid, i + dir[0], j + dir[1]);
        }
    }
};

class Solution {
    // 设置矩阵的行和列
    public int m;
    public int n;

    // 访问格子的四个方向的格子
    public int[][] dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

    public int numEnclaves(int[][] grid) {
        m = grid.length;
        n = grid[0].length;
        // 遍历矩阵的四周，进行遍历，如果是海洋(0)的话则会停止递归，反之则继续
        for (int i = 0; i < m; i++) {
            dfs(grid, i, 0);
            dfs(grid, i, n - 1);
        }
        for (int i = 0; i < n; i++) {
            dfs(grid, 0, i);
            dfs(grid, m - 1, i);
        }

        // 定义结果变量
        int res = 0;
        // 在递归结束以后，所有能和边界接触到的陆地都会被置为 0 
        // 因此只需要遍历矩阵之中剩余陆地(1)的数量就是最后的结果
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 1) {
                    res++;
                }
            }
        }
        return res;
    }

    public void dfs(int[][] grid, int i, int j) {
        // 如果 grid[i][j] 不在范围或者是海洋，就停止递归
        if (i < 0 || j < 0 || i >= m || j >= n || grid[i][j] == 0) {
            return;
        }
        // 将陆地置为海洋
        grid[i][j] = 0;
        // 遍历周围的四个方向的格子，继续进行递归操作
        for (int[] dir : dirs) {
            dfs(grid, i + dir[0], j + dir[1]);
        }
    }
}

• 时间复杂度 O($mn$)
• 空间复杂度 O($mn$)

法二：广搜

从四周开始进行搜索，能够访问到的陆地 (1) 将 visited 置为 1 ，判断周围四个方向的格子是否有陆地，如果有则继续放入队列，等待进行下一次的搜索，知道最后队列为空即可结束

class Solution {  
public:
    int m, n;
    vector<vector<int>> dirs = {{1,  0},
                                {-1, 0},
                                {0,  1},
                                {0,  -1}};


    int numEnclaves(vector<vector<int>> &grid) {
        queue<pair<int, int>> qu;
        m = grid.size();
        n = grid[0].size();
        vector<vector<bool>> visited(m, vector<bool>(n, false));
        for (int i = 0; i < m; i++) {
            if (grid[i][0] == 1) {
                visited[i][0] = true;
                qu.emplace(i, 0);
            }
            if (grid[i][n - 1] == 1) {
                visited[i][n - 1] = true;
                qu.emplace(i, n - 1);
            }
        }
        for (int i = 1; i < n-1; i++) {
            if (grid[0][i] == 1) {
                visited[0][i] = true;
                qu.emplace(0, i);
            }
            if (grid[m - 1][i] == 1) {
                visited[m - 1][i] = true;
                qu.emplace(m - 1, i);
            }
        }

        while (!qu.empty()) {
            auto [r, c]=qu.front();
            qu.pop();
            for (vector<int> dir: dirs) {
                int x = r + dir[0], y = c + dir[1];
                if (x >= 0 && y >= 0 && x < m && y < n && grid[x][y] == 1&& !visited[x][y] ) {
                    visited[x][y] = true;
                    qu.emplace(x, y);
                }
            }
        }

        int res = 0;
        for (int i = 1; i < m-1; i++) {
            for (int j = 1; j < n-1; j++) {
                if (grid[i][j] == 1 && !visited[i][j]) {
                    res++;
                }
            }
        }
        return res;
    }
};

class Solution {
    public static int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    public int numEnclaves(int[][] grid) {
        int m = grid.length, n = grid[0].length;
        boolean[][] visited = new boolean[m][n];
        Queue<int[]> queue = new ArrayDeque<int[]>();
        for (int i = 0; i < m; i++) {
            if (grid[i][0] == 1) {
                visited[i][0] = true;
                queue.offer(new int[]{i, 0});
            }
            if (grid[i][n - 1] == 1) {
                visited[i][n - 1] = true;
                queue.offer(new int[]{i, n - 1});
            }
        }
        for (int j = 1; j < n - 1; j++) {
            if (grid[0][j] == 1) {
                visited[0][j] = true;
                queue.offer(new int[]{0, j});
            }
            if (grid[m - 1][j] == 1) {
                visited[m - 1][j] = true;
                queue.offer(new int[]{m - 1, j});
            }
        }
        while (!queue.isEmpty()) {
            int[] cell = queue.poll();
            int r = cell[0], c = cell[1];
            for (int[] dir : dirs) {
                int x = r + dir[0], y = c + dir[1];
                if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1 && !visited[x][y]) {
                    visited[x][y] = true;
                    queue.offer(new int[]{x, y});
                }
            }
        }
        int res = 0;
        for (int i = 1; i < m - 1; i++) {
            for (int j = 1; j < n - 1; j++) {
                if (grid[i][j] == 1 && !visited[i][j]) {
                    res++;
                }
            }
        }
        return res;
    }
}

• 时间复杂度 O($mn$)
• 空间复杂度 O($mn$)

与之相似的题目还有：

• 剑指 Offer II 105. 岛屿的最大面积
• 1765. 地图中的最高点