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( m n mn mn)
  • 空间复杂度 O( m n mn 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( m n mn mn)
  • 空间复杂度 O( m n mn mn)
与之相似的题目还有:
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值