DFS - leetcode-岛屿问题（合集）

最新推荐文章于 2023-03-22 11:00:00 发布
最新推荐文章于 2023-03-22 11:00:00 发布
阅读量437 收藏
点赞数
分类专栏： leetcode 文章标签： leetcode dfs java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56915683/article/details/119972626
版权

在 leetcode 上写 DFS 时，看到了 nettee 老哥的-DFS 框架，于是写了几道 岛屿问题 练练手

岛屿问题：

在这里插入图片描述

200. 岛屿数量

本质上就是 求图中 连通分量的个数

求图中 连通分量个数的方法（3 种）：

  • DFS
  • BFS
  • 并查集

详细题解，见 DFS & BFS & 并查集 -leetcode-200. 岛屿数量

463. 岛屿的周长

在这里插入图片描述在这里插入图片描述

本题 求的是 连通分量的最外侧周长

思路：

  • 数据较小， [1, 100]，直接 dfs 爆搜，即可
  • 由图可知，如果当前是陆地，并且从当前位置 扩展的“新位置”是“水坑”或“新位置“越界，则会为周长贡献一条边；否则（即，新位置已经被遍历过了），不会为 周长贡献 边

这里使用的是 zju_ds dfs 魔板，当然本题也可以采用 nettee 老哥的-DFS 框架 + 带有返回值 inrt 的 DFS （见 827. 最大人工岛 代码）

class Solution {
    // 上下左右 4 个方向
    int[] dirx = {-1, 1, 0, 0};
    int[] diry = {0, 0, -1, 1};
    // 全局变量
    int[][] grid;
    boolean[][] visited;
    int m; // 行
    int n; // 列
    int res = 0; // 岛屿周长

    public int islandPerimeter(int[][] grid) {
        this.grid = grid;
        this.m = grid.length;
        this.n = grid[0].length;
        this.visited = new boolean[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 1 && !visited[i][j]) {
                    dfs(i, j);
                }
            }
        }
        return res;
    }

    public void dfs(int x, int y) {
        visited[x][y] = true; // 标记
        for (int i = 0; i < 4; i++) {
            int xx = x + dirx[i];
            int yy = y + diry[i];
            // 当前是陆地，并且从当前位置 扩展的“新位置”是“水坑”或“新位置“越界，则会为周长贡献一条边
            // System.out.println("xx = " + xx);
            // System.out.println("yy = " + yy);
            if (xx < 0 || xx >= m || yy < 0 || yy >= n || grid[xx][yy] == 0) {
                res++;
                continue;
            }
            if (visited[xx][yy]) { // 此时不会为周长“贡献“一条边
                continue;
            }
            dfs(xx, yy);
        }
    }
}

695. 岛屿的最大面积

在这里插入图片描述
注意: 给定的矩阵grid 的长度和宽度都不超过 50。

本题其实就是求 “最大”（顶点数最多）的连通分量

思路：

  • 数据较小， [1, 50]，直接经典 dfs 爆搜，即可
  • 经典 DFS 求每个连通分量的个数，然后取最大值

这里使用的是 zju_ds dfs 魔板，当然本题也可以采用 nettee 老哥的-DFS 框架 + 带有返回值 inrt 的 DFS （见 827. 最大人工岛 代码）

class Solution {
    // 上下左右 4 个方向
    int[] dirx = {-1, 1, 0, 0};
    int[] diry = {0, 0, -1, 1};
    // 全局变量
    int[][] grid;
    boolean[][] visited;
    int m; // 行
    int n; // 列
    int area; // 当前所在岛屿的面积
    int maxArea = 0; // 岛屿最大面积

    public int maxAreaOfIsland(int[][] grid) {
        this.grid = grid;
        this.m = grid.length;
        this.n = grid[0].length;
        this.visited = new boolean[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 1 && !visited[i][j]) {
                    area = 1;
                    dfs(i, j);
                    maxArea = Math.max(area, maxArea);
                }
            }
        }
        return maxArea;
    }

    public void dfs(int x, int y) {
        visited[x][y] = true; // 标记
        for (int i = 0; i < 4; i++) {
            int xx = x + dirx[i];
            int yy = y + diry[i];
            // System.out.println("xx = " + xx);
            // System.out.println("yy = " + yy);
            if ((xx < 0 || xx >= m || yy < 0 || yy >= n) || visited[xx][yy] || grid[xx][yy] == 0) {
                continue;
            }
            // “有效的“ dfs 次数，即为当前所在岛屿的 面积
            area++;
            dfs(xx, yy);
        }
    }
}

827. 最大人工岛

在这里插入图片描述
提示：

  • n == grid.length
  • n == grid[i].length
  • 1 <= n <= 500
  • grid[i][j] 为 0 或 1

思路：

  • DFS 尝试填充每一个 “水坑”，然后取最大值。 TLE
  • 两次 DFS + 哈希表 + 染色 AC

DFS 尝试填充每一个 “水坑” TLE

错误做法 1：求 top2 的连通分量 WA

  • 最开始想的是，类似 695. 岛屿的最大面积 求 top2 的连通分量，然后加一。后来一想，觉得不可，因为 为这两个 top2 的岛屿 添加一个“陆地”后 不一定 连通

错误做法 2：DFS 尝试填充每一个 “水坑” TLE

  • 将当前海洋格子 “填海造陆” gird[i][j] = 1 (即，一次填海造陆） ；
  • 然后从当前 “海洋格子” 出发 DFS 求连通分量的顶点数；
  • 本次 DFS 完事后，需要进行回溯（即，gird[i][j] = 0，将 填的海洋 还原回去，以待后面其他位置 “填海造陆” ）

注意：这里不同于 “岛屿数量” & “岛屿最大面积”（只用 visited 全局初始化一次），这里每次以 (i, j) 水坑开始 dfs 之前，都要初始化 visited

但是，这样写超时了

class Solution {
    // 上下左右 4 个方向
    int[] dirx = {-1, 1, 0, 0};
    int[] diry = {0, 0, -1, 1};
    // 全局变量
    int[][] grid;
    boolean[][] visited;
    int m; // 行
    int n; // 列
    int area; // 当前所在岛屿的面积
    int maxArea = 0; // 岛屿最大面积

    public int largestIsland(int[][] grid) {
        for (int[] line : grid) {
            System.out.println(Arrays.toString(line));
        }
        this.grid = grid;
        this.m = grid.length;
        this.n = grid[0].length;
        this.visited = new boolean[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 0) { // 尝试填充每个 水坑
                    // 这里不同于 “岛屿数量” & “岛屿最大面积”（只用 visited 全局初始化一次）
                    // 这里每次以 (i, j) 水坑开始 dfs 之前，都要初始化 visited
                    for (boolean[] line : visited) {
                        Arrays.fill(line, false);
                    }

                    System.out.println("----------------");
                    System.out.println("i = " + i);
                    System.out.println("j = " + j);
                    grid[i][j] = 1; // 将当前 “水坑” 填成“陆地”
                    area = 1;
                    dfs(i, j);
                    grid[i][j] = 0; // 回溯
                    System.out.println("area = " + area);
                    maxArea = Math.max(area, maxArea);
                }
            }
        }
        return maxArea == 0 ? m * n : maxArea;
    }

    public void dfs(int x, int y) {
        visited[x][y] = true; // 标记
        for (int i = 0; i < 4; i++) {
            int xx = x + dirx[i];
            int yy = y + diry[i];
            // System.out.println("xx = " + xx);
            // System.out.println("yy = " + yy);
            if ((xx < 0 || xx >= m || yy < 0 || yy >= n) || visited[xx][yy] || grid[xx][yy] == 0) {
                continue;
            }
            // “有效的“ dfs 次数，即为当前所在岛屿的 面积
            // System.out.println("xx = " + xx);
            // System.out.println("yy = " + yy);
            area++;
            dfs(xx, yy);
        }
    }
}

在这里插入图片描述

两次 DFS + 哈希表 + 染色 AC

参考 nettee 老哥的-DFS 框架

采用两次遍历

  1. 第一次 DFS 遍历 “陆地”，记录每个岛屿的面积

    • 这里将 已经访问过的 岛屿 标记为 “岛屿索引号” index（grid 中已经有 0、1 了，为了区分 所以从 2 开始），而不是面积
    • 采用 map 记录每个岛屿序号为 index 的“面积”

  2. 第二次 dfs：遍历海洋格子，尝试将 “海洋格子” 和 周围的 “岛屿” 合并，取 max

    • 找当前海洋格子的邻居节点，如果是两个岛屿 则合并之

采用 nettee 老哥的-DFS 框架，类似二叉树 dfs 魔板 + 哈希表 + 两次遍历 + 染色

import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

class Solution {
    // 上下左右 4 个方向
    int[] dirx = {-1, 1, 0, 0};
    int[] diry = {0, 0, -1, 1};
    // 全局变量
    int[][] grid;
    // boolean[][] visited; // 直接利用 grid 标记
    /**
     * 不用 visited 标记，改用 grid 标记访问状态
     * grid[i][j] == 0 ：水坑
     * grid[i][j] == 1 ：陆地
     * grid[i][j] == idnex ：已经访问过的 岛屿，并被标记为 已经访问过
     */
    int m; // 行
    int n; // 列

    public int largestIsland(int[][] grid) {
        this.grid = grid;
        this.m = grid.length;
        this.n = grid[0].length;
        int res = 0;
        int index = 2; // 给岛屿 记录“索引号”（grid 中已经有 0、1 了，为了区分 所以从 2 开始）
        Map<Integer, Integer> map = new HashMap<>(); // 记录每个岛屿的“面积”。key：index；value：岛屿面积
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 1) { // 记录每个岛屿的面积
                    int area = dfs(i, j, index); // 局部变量（改用 类似二叉树魔板 + 待返回值的 dfs时，不能将 area 设为全局变量）
                    res = Math.max(res, area);
                    map.put(index++, area); // 记录每个岛屿序号为 index 的“面积”
                }
            }
        }
        System.out.println(map);
        for (int[] g : grid) {
            System.out.println(Arrays.toString(g));
        }
        // 第二次 dfs：遍历海洋格子
        if (res == 0) { // 全是海洋格子
            return 1;
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 0) {
                    HashSet<Integer> set = findNeighbors(i, j); // 找当前海洋格子的邻居节点，如果是两个岛屿 则合并之
                    System.out.println("set = " + set);
                    if (set.size() < 1) {
                        continue;
                    }
                    int cnt = 1;
                    for (Integer islandIndex : set) {
                        cnt += map.get(islandIndex);
                    }
                    res = Math.max(cnt, res);
                }
            }
        }
        return res;
    }

    /**
     * 找 (x, y) 所在 “水坑” 上下左右 4 个方向的 岛屿索引号
     * @param x
     * @param y
     * @return
     */
    public HashSet<Integer> findNeighbors(int x, int y) {
        HashSet<Integer> set = new HashSet<>();
        for (int i = 0; i < 4; i++) {
            int xx = x + dirx[i];
            int yy = y + diry[i];
            if (xx < 0 || xx >= m || yy < 0 || yy >= n || grid[xx][yy] == 0) { // 越界，或者新位置 是“水坑”，则不必看
                continue;
            }
            set.add(grid[xx][yy]); // 收集 (x, y) 邻居 (xx, yy) 所在岛屿的 索引号
        }
        return set;
    }

    public int dfs(int x, int y, int index) {
        // 终止条件（网格出界，类似二叉树走到叶子节点）
        if (x < 0 || x >= m || y < 0 || y >= n) {
            return 0;
        }
        // 避免重复访问
        if (grid[x][y] != 1) { // 此时，从上面的终止条件 下来了，所以 (x, y) 一定不会越界
            return 0;
        }

        grid[x][y] = index; // 标记
        int area = 0;
        for (int i = 0; i < 4; i++) {
            int xx = x + dirx[i];
            int yy = y + diry[i];
            // “有效的“ dfs 次数，即为当前所在岛屿的 面积
            area += dfs(xx, yy, index); // 类似于二叉树，求左右孩子个数之和
        }
        return area + 1; // 类似于二叉树，左右孩子 + 本身，就是以当前节点为 root 的子树节点个数
    }

    public static void main(String[] args) {
        int[][] grid = {{1, 1}, {1, 1}};
        System.out.println(new Solution().largestIsland(grid));
    }
}

这题写的真费劲，太菜了

在这里插入图片描述

pospre
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
php-leetcode题解之岛屿数量.zip
06-08
而“岛屿数量”这个问题是LeetCode中的经典题目之一，它涉及到图论和深度优先搜索（DFS）或广度优先搜索（BFS）等算法。 首先，我们需要理解“岛屿数量”问题的背景。在这个问题中，给定一个由'0'和'1'组成的二维...
LeetCode 岛屿系列全解析 200. 463. 1905. 1254. 695. 827. 694. 711
vcj1009784814的博客
05-11 1239
题目描述 给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。 DFS 其实就是求连通块的个数。这道题可以通过DFS，BFS，并查集，三种方法来做。 先说比较简单的DFS: 两层循环，对每个为1的位置，进行DFS，把跟这个点相连的所有点都访问一遍，并且访问后将该位置置为0，以便后续不会重复访问。 class Solution { // 4个方向 int[] dx = {1, -
Leetcode岛屿问题系列分析
qq_39144436的博客
04-14 1971
在 LeetCode 中，「岛屿问题」是一个系列系列问题，比如： 200. 岛屿数量（Medium） 463. 岛屿的周长（Easy） 695. 岛屿的最大面积（Medium） 827. 最大人工岛（Hard） 我们所熟悉的 DFS（深度优先搜索）问题通常是在树或者图结构上进行的。而我们今天要讨论的 DFS 问题，是在一种「网格」结构中进行的。岛屿问题是这类网格 DFS 问题的典型代表。网格结构遍历起来要比二叉树复杂一些，如果没有掌握一定的方法，DFS 代码容易写得冗长繁杂。 本文将以...
leetcode系列之岛屿问题
u013518289的专栏
08-27 1276
在leetcode里的深度优先遍历的题目集中，有很多题几乎有着相同的解题思路，其中的岛屿问题就是如此，对应的题目有被围绕的区域，岛屿数量，岛屿的最大面积和统计封闭岛屿的数目，水域大小。在深度优先遍历的时候，往往有个难点就是如何记录当前已经被访问过的节点，如果不做处理的话，很有可能会造成递归，常规的解题思路是用一个visited数组来表示是否已经访问，它有个好处就是不改变原有数据里面的状态，但是同时额外带来些空间消耗。但是在解岛屿问题的时候，我们可能会发现通过直接更改访问节点的状态，可以使我们程序不重复访问某
岛屿问题
如故的博客
08-12 4321
岛屿个数问题 1 是陆地, 0 是水, 只考虑上下左右四个方向相邻 例如: 输入: 11110 11010 11000 00000 输出: 1 思路: 遍历二维数组, 如果是 1, 就把它上下左右都感染为 2, 岛屿个数 +1 遍历完成, 最后返回岛屿个数 感染的时候可以用递归 class Solution { public: int numIslands(vect...
LeetCode岛屿问题通用解决模板
自律使我自由
03-22 654
岛屿类问题，最简单的处理方式就是使用深度优先遍历来解，找到一个陆地后，不断的向其上下左右四个方向进行遍历，直到抵达边界或者水域为止。我们先从一道LeetCode上的题目了解一下一般岛屿类题目的问题场景。通过上面6题，应该可以体会出通用解决模板的套路，无论题目如何变化，其边界判断、水域、陆地判断、上下左右遍历都是非常标准的解决岛屿问题的方式，只要掌握了这个套路，其他无非就是在其基础上演化处理而已。
leetcode迷宫问题-leetcode:leetcode
06-30
leetcode迷宫问题 leetcode by 没有感情的刷题机器 主要根据《挑战程序设计竞赛》的章节，结合leetcode加强练习 src/packagegame下为题目的源代码 Java_foundation下为Java的基础知识（复习整理中） 进度 charpter1 ...
leetcode岛屿面积-leetcode-gitbook:用于leetcode问题的gitbook
06-30
在本项目中，“leetcode岛屿面积-leetcode-gitbook:用于leetcode问题的gitbook”是一个与LeetCode平台相关的开源项目，旨在整理并记录LeetCode上的算法题目及其解决方案。LeetCode是一个在线平台，提供各种编程挑战...
java-leetcode题解之第200题岛屿数量.zip
最新发布
06-18
标题中的“java-leetcode题解之第200题岛屿数量”表明这是一份关于解决LeetCode编程挑战的Java代码实现，具体是第200题，名为“岛屿数量”。LeetCode是一个在线平台，提供了各种算法题目来帮助程序员提升技能和准备...
go-LeetCode问题解决方案
02-08
在LeetCode中，DFS常用于解决组合问题、岛屿数量、二叉树的遍历等问题。例如，解决“岛屿数量”问题时，我们可以将网格视为一个二维图，用DFS来标记已访问过的陆地，并统计出所有岛屿的数量。 回溯法是一种试探性的...
LeetCode 例题精讲 | 12 岛屿问题：网格结构中的 DFS
nettee的专栏
04-15 553
本期例题为 LeetCode「岛屿问题」系列：LeetCode 463. Island Perimeter 岛屿的周长（Easy）LeetCode 695. Max Area of Is...
华为二面找小岛个数
qq_43008645的博客
09-17 310
给你一个由'1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 示例 1: 输入: [ ['1','1','1','1','0'], ['1','1','0','1','0'], ['1','1','0','0','0'], ['0','0','0','0','0'] ] 输出: 1 class Solution { int count=0; .
连通块【岛问题】总结
weixin_42637495的博客
11-25 368
题目： 给出一个mxn 的矩阵，矩阵中的元素为0或1。称位置（x，y）与其上下左右四个位置（x，y+1）、（x，y-1）、（x+1，y）、（x-1，y）是相邻的。如果矩阵中有若干个1是相邻的（不必两两相邻），那么称这些1构成了一个“块”。求给定的矩阵中“块”的个数。 　　0 1 1 1 0 0 1 0 0 1 0 0 0 0 　　0 0 0 0 1 0 0 　　0 0 0 1...
【HDU - 1241】Oil Deposits （连通块问题 属于求大海中的岛屿个数 类似问题）
xuanweiace的博客
07-15 436
题干：   The GeoSurvComp geologic survey company is responsible for detecting underground oil deposits. GeoSurvComp works with one large rectangular region of land at a time, and creates a grid that di...
岛屿数量（图连通题目）
qq_40570410的博客
05-31 464
给定一个M N，表示这个整型数组的大小 6 7 0 1 1 1 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 0 1 1 1 0 1 0 0 1 1 1 1 0 0 0 0表示海水，1表示陆地，一堆连起来的1表示一个岛屿，求出岛屿数 这个题目是典型题目，我们下面给出BFS的解法： #include <iostream> #include <queue> #define MAXN 100 using namespace std.
LeetCode 题解——岛屿数量
fe_watermelon的博客
02-12 5089
大家好，我是前端西瓜哥，今天我们做一道经典算法题——岛屿数量。 LeetCode 上对应题目为 200 题：https://leetcode-cn.com/problems/number-of-islands/ 这道题归属于岛屿问题，是有固定套路的，那就是 Flood fill 算法。 Flood fill 算法 Flood fill 算法是一种特殊的算法，它在一个区域内，从某个点开始往外扩散找到与其联通的所有点，最终获得一个区域块。 从一个点开始覆盖整个区域的过程，因很像洪水淹没一个岛屿的过程，所以被命
Leetcode——岛屿问题
Yawn
08-19 1054
1.前置 先明确一下岛屿问题中的网格结构是如何定义的，网格问题是由 m×n 个小方格组成一个网格，每个小方格与其上下左右四个方格认为是相邻的，要在这样的网格上进行某种搜索。 岛屿问题是一类典型的网格问题。每个格子中的数字可能是 0 或者 1。我们把数字为 0 的格子看成海洋格子，数字为 1 的格子看成陆地格子，这样相邻的陆地格子就连接成一个岛屿。 DFS 的基本结构： 网格结构要比二叉树结构稍微复杂一些，它其实是一种简化版的图结构。要写好网格上的 DFS 遍历，我们首先要理解二叉树上的 DF
LeetCode刷题—岛屿问题
qq_39181839的博客
02-16 738
思路 一个二维矩阵从某个点开始向四周扩展，直到无法再扩展为止。 矩阵，可以抽象为一幅「图」，这就是⼀个图的遍历问题，也就类似⼀个 N 叉树遍历的问题。几行代码就能解决，直接上框架吧： // (x, y) 为坐标位置 void fill(int x, int y) { fill(x - 1, y); // 上 fill(x + 1, y); // 下 fill(x, y - 1); // 左 fill(x, y + 1); // 右 } 这个框架可以解决所有在二维矩阵中遍历的问题，说得
Leetcode200-查找岛屿数量详解
白羊by的博客
07-25 341
Leetcode200-查找岛屿数量详解
用C++编写电话号码的字母组合-LeetCode
06-07
好的，下面是电话号码的字母组合问题的 C++ 代码实现： ``` class Solution { public: vector<string> letterCombinations(string digits) { unordered_map, string> mapping = { {'2', "abc"}, {'3', "def"}, {...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值