Day45 | 99.岛屿数量 深搜 广搜 100.岛屿的最大面积

最新推荐文章于 2024-10-01 04:50:10 发布
最新推荐文章于 2024-10-01 04:50:10 发布
阅读量1.1k 收藏 22
点赞数 39
文章标签： 算法 数据结构 java 面试 深度优先 广度优先 岛屿问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q864508127/article/details/141437110
版权

语言

Java

99.岛屿数量 深搜 广搜

99. 岛屿数量

题目

题目描述

给定一个由 1（陆地）和 0（水）组成的矩阵，你需要计算岛屿的数量。岛屿由水平方向或垂直方向上相邻的陆地连接而成，并且四周都是水域。你可以假设矩阵外均被水包围。

输入描述

第一行包含两个整数 N, M，表示矩阵的行数和列数。

后续 N 行，每行包含 M 个数字，数字为 1 或者 0。

输出描述

输出一个整数，表示岛屿的数量。如果不存在岛屿，则输出 0。

思路（深搜版本）

第一次思路

1.创建一个二维数组
2.通过Scanner输入多少就是几乘几的二维数组，定义一个结果res

3.这时我们得到一个二维数组，遍历二维数组，找到为1的地方

4.？如何看他周围有没有1组成个大岛屿
5.如果是大岛屿res+1

6.输出res的值

最终思路

  1. 初始化：
    • 读取网格的大小（行数和列数）。
    • 创建一个与网格大小相同的二维数组grid来存储输入数据。
    • 创建一个同样大小的二维布尔数组visited，用于跟踪哪些陆地（1）已经被访问过。初始时，所有位置都设为false。
  2. 遍历网格：
    • 使用两层嵌套循环遍历网格中的每一个位置。
    • 对于每个位置，检查它是否是陆地（grid[i][j] == 1）且尚未被访问（visited[i][j] == false）。
  3. 深度优先搜索（DFS）：
    • 如果发现一个未被访问的陆地，那么我们就找到了一个新的岛屿。此时，将岛屿计数器加一。
    • 对这个陆地位置执行DFS，以标记与这个陆地相连的所有陆地（即这个岛屿的所有部分）为已访问。
    • DFS过程中，我们遍历当前陆地位置的四个相邻方向（上、下、左、右），如果相邻位置是陆地且未被访问，则递归地对该位置执行DFS。
  4. 结果输出：
    • 遍历和DFS完成后，岛屿计数器的值即为网格中岛屿的总数。
    • 输出岛屿的总数。

代码

import java.util.Scanner;  
  
public class Main {  
    static final int[][] dir = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}}; // 四个方向  
  
    static void dfs(int[][] grid, boolean[][] visited, int x, int y) {  
        for (int i = 0; i < 4; i++) {  
            int nextx = x + dir[i][0];  
            int nexty = y + dir[i][1];  
            if (nextx < 0 || nextx >= grid.length || nexty < 0 || nexty >= grid[0].length) continue;  // 越界了，直接跳过  
            if (!visited[nextx][nexty] && grid[nextx][nexty] == 1) { // 没有访问过的 同时 是陆地的  
                visited[nextx][nexty] = true;  
                dfs(grid, visited, nextx, nexty);  
            }  
        }  
    }  
  
    public static void main(String[] args) {  
        Scanner scanner = new Scanner(System.in);  
        int n = scanner.nextInt();  
        int m = scanner.nextInt();  
        int[][] grid = new int[n][m];  
        boolean[][] visited = new boolean[n][m];  
  
        for (int i = 0; i < n; i++) {  
            for (int j = 0; j < m; j++) {  
                grid[i][j] = scanner.nextInt();  
            }  
        }  
  
        int result = 0;  
        for (int i = 0; i < n; i++) {  
            for (int j = 0; j < m; j++) {  
                if (!visited[i][j] && grid[i][j] == 1) {  
                    visited[i][j] = true;  
                    result++; // 遇到没访问过的陆地，+1  
                    dfs(grid, visited, i, j); // 将与其链接的陆地都标记上 true  
                }  
            }  
        }  
  
        System.out.println(result);  
    }  
}

易错点

  • DFS：深度优先搜索是解决此类问题的关键。它允许我们从一个陆地位置开始，探索并标记与该位置相连的所有陆地，直到没有更多的相邻陆地为止。
  • 避免重复计数：通过visited数组，我们可以确保每个岛屿只被计数一次。即使一个岛屿由多个陆地组成，DFS也会确保我们只在首次遇到岛屿时增加计数器，并标记岛屿的所有部分为已访问。
  • 边界条件：在DFS过程中，我们需要检查相邻位置是否越界（即是否仍在网格范围内内），以及相邻位置是否是陆地且未被访问

思路（广搜版本）

  1. 理解问题：
    • 首先，明确问题的要求。例如，在网格中，你可能需要计算由1（代表陆地）组成的连通区域的数量。
  2. 初始化：
    • 创建一个与网格大小相同的visited数组（或类似的数据结构），用于跟踪哪些位置已经被访问过。
    • 创建一个队列（如LinkedList），用于BFS的遍历。
  3. 遍历网格：
    • 遍历网格的每个位置。
    • 对于每个位置，如果它是陆地（即值为1）且尚未被访问过，则将其视为一个新的连通区域。
  4. BFS遍历：
    • 将当前位置加入队列，并标记为已访问。
    • 当队列不为空时，从队列中取出一个位置，并检查其四个相邻位置（上、下、左、右）。
    • 如果相邻位置是陆地且未被访问过，则将其加入队列并标记为已访问。
    • 重复此过程，直到队列为空。
  5. 计数：
    • 对于每个新发现的连通区域，增加计数器。
  6. 输出结果：
    • 遍历结束后，输出连通区域的数量。

代码

import java.util.LinkedList;  
import java.util.Queue;  
import java.util.Scanner;  
import java.util.Vector;  
  
public class Main {  
    private static final int[][] DIRECTIONS = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}}; // 四个方向  
  
    public static void bfs(int[][] grid, boolean[][] visited, int x, int y) {  
        Queue<int[]> que = new LinkedList<>();  
        que.offer(new int[]{x, y});  
        visited[x][y] = true; // 只要加入队列，立刻标记  
  
        while (!que.isEmpty()) {  
            int[] cur = que.poll();  
            int curx = cur[0];  
            int cury = cur[1];  
  
            for (int i = 0; i < 4; i++) {  
                int nextx = curx + DIRECTIONS[i][0];  
                int nexty = cury + DIRECTIONS[i][1];  
  
                if (nextx < 0 || nextx >= grid.length || nexty < 0 || nexty >= grid[0].length) continue; // 越界了，直接跳过  
                if (!visited[nextx][nexty] && grid[nextx][nexty] == 1) {  
                    que.offer(new int[]{nextx, nexty});  
                    visited[nextx][nexty] = true; // 只要加入队列立刻标记  
                }  
            }  
        }  
    }  
  
    public static void main(String[] args) {  
        Scanner scanner = new Scanner(System.in);  
        int n = scanner.nextInt();  
        int m = scanner.nextInt();  
        int[][] grid = new int[n][m];  
        boolean[][] visited = new boolean[n][m];  
  
        for (int i = 0; i < n; i++) {  
            for (int j = 0; j < m; j++) {  
                grid[i][j] = scanner.nextInt();  
            }  
        }  
  
        int result = 0;  
        for (int i = 0; i < n; i++) {  
            for (int j = 0; j < m; j++) {  
                if (!visited[i][j] && grid[i][j] == 1) {  
                    result++; // 遇到没访问过的陆地，+1  
                    bfs(grid, visited, i, j); // 将与其链接的陆地都标记上 true  
                }  
            }  
        }  
  
        System.out.println(result);  
    }  
}

易错点

  1. 边界检查：
    • 在检查相邻位置时，容易忘记检查它们是否越界（即是否在网格的范围内）。
  2. 重复访问：
    • 如果没有正确地使用visited数组（或类似的数据结构），可能会导致同一个位置被多次访问，从而影响结果。

100.岛屿的最大面积

100. 岛屿的最大面积

题目

题目描述

给定一个由 1（陆地）和 0（水）组成的矩阵，计算岛屿的最大面积。岛屿面积的计算方式为组成岛屿的陆地的总数。岛屿由水平方向或垂直方向上相邻的陆地连接而成，并且四周都是水域。你可以假设矩阵外均被水包围。

输入描述

第一行包含两个整数 N, M，表示矩阵的行数和列数。后续 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。

输出描述

输出一个整数，表示岛屿的最大面积。如果不存在岛屿，则输出 0。

思路

  1. 输入读取：

    • 读取网格的行数n和列数m。
    • 读取网格的数据，存储在二维数组grid中。

  2. 初始化：

    • 初始化一个与grid大小相同的二维布尔数组visited，用于标记每个位置是否被访问过。

  3. 遍历网格：

    • 遍历整个网格，对于每个未访问的陆地（即grid[i][j] == 1且!visited[i][j]），执行以下操作：
      • 初始化count为1，表示当前岛屿的大小。
      • 标记当前位置为已访问。
      • 调用DFS函数，遍历并标记所有相邻的陆地。
      • 更新最大岛屿大小result。

  4. DFS函数：

    • 从当前位置(x, y)出发，遍历四个方向的相邻位置。
    • 如果相邻位置越界或不是陆地或已经访问过，则跳过。
    • 否则，标记该位置为已访问，增加count，并递归调用DFS函数。

  5. 输出结果：

    • 输出最大的岛屿大小result。

代码

import java.util.Scanner;

public class Main {
    private static int count;
    private static final int[][] dir = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}}; // 四个方向

    public static void dfs(int[][] grid, boolean[][] visited, int x, int y) {
        for (int i = 0; i < 4; i++) {
            int nextx = x + dir[i][0];
            int nexty = y + dir[i][1];
            if (nextx < 0 || nextx >= grid.length || nexty < 0 || nexty >= grid[0].length) continue;  // 越界了，直接跳过
            if (!visited[nextx][nexty] && grid[nextx][nexty] == 1) { // 没有访问过的 同时 是陆地的
                visited[nextx][nexty] = true;
                count++;
                dfs(grid, visited, nextx, nexty);
            }
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int[][] grid = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                grid[i][j] = scanner.nextInt();
            }
        }
        boolean[][] visited = new boolean[n][m];
        int result = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (!visited[i][j] && grid[i][j] == 1) {
                    count = 1;  // 因为dfs处理下一个节点，所以这里遇到陆地了就先计数，dfs处理接下来的相邻陆地
                    visited[i][j] = true;
                    dfs(grid, visited, i, j); // 将与其链接的陆地都标记上 true
                    result = Math.max(result, count);
                }
            }
        }
        System.out.println(result);
    }
}

易错点

数组越界：

在DFS函数中，需要检查下一个位置是否越界。如果越界，直接跳过。
示例代码中已经包含了越界检查：

总结

今天了解深搜和广搜的思路，做了模板题岛屿问题。

明天继续加油！

道阻且长，行则将至。

086小包字
关注
代码随想录Day51|99.岛屿数量 深搜 99.岛屿数量 广搜 岛屿的最大面积
weixin_44426359的博客
09-23 74
【代码】代码随想录Day51|99.岛屿数量 深搜 99.岛屿数量 广搜 岛屿的最大面积。
Studying-代码随想录训练营day51| 99.岛屿数量 深搜、99.岛屿数量 广搜、100.岛屿的最大面积
yachihaoteng的博客
08-02 580
99.岛屿数量 深搜、99.岛屿数量 广搜、100.岛屿的最大面积
代码随想录算法训练营day65 | 99. 岛屿数量 深搜、99. 岛屿数量 广搜、100. 岛屿的最大面积
sunflowers11的博客
06-25 235
本次题目都是卡码网上的。
day 65 图论part02 99.岛屿数量 深搜 99.岛屿数量 广搜 100.岛屿的最大面积
m0_68259754的博客
06-23 675
每座岛屿只能由相邻的陆地连接形成。本题思路，是用遇到一个没有遍历过的节点陆地，计数器就加一，然后把该节点陆地所能遍历到的陆地都标记上。在遇到标记过的陆地节点和海洋节点的时候直接跳过。这样计数器就是最终岛屿的数量。那么如何把节点陆地所能遍历到的陆地都标记上呢，就可以使用 DFS，BFS或者并查集。
刷题Day54|99. 岛屿数量、100. 岛屿的最大面积
sanwanaaa的博客
07-16 194
深搜思路：从一个unvisited的结点开始dfs遍历它所有能到的节点并标为visited，然后res+=1。广搜思路：使用bfs来遍历一个unvisited的节点所能到的节点，进queue标记为visited。思路：在【99. 岛屿数量】的基础上，要记录每个岛屿的面积，最后取最大值。注意：也可以利用沉岛思路，访问过的岛屿都置为0。
day 51 第十一章：图论part02 99.岛屿数量 深搜 99.岛屿数量 广搜 100.岛屿的最大面积
2302_78039690的博客
08-02 261
思路：遇到一个没有遍历过的节点陆地，计数器就加一，然后标记该节点陆地所能遍历到的所有陆地。dfs函数：此题就一个递归终止条件所以不用写确定递归终止的条件，然后确定单层递归逻辑，分别向上右下左四个方向进行递归，符合条件的继续下一层递归。2.一般dfs里面有两个终止递归的地方，一个在确定递归终止条件里，一个在确定单层递归逻辑里，如果当前限制条件较少，这两个终止条件只能写一个，否则答案会错误。一圈一圈地遍历），然后将符合条件的节点压入队列中并标记，然后在弹出队列中的元素一圈一圈的遍历循环往复一直到队列为空。
代码随想录训练营Day 65|卡码网99岛屿数量 深搜、99.岛屿数量 广搜 、100.岛屿的最大面积
weixin_64434454的博客
06-21 450
代码：（在符合递归条件时进行递归处理）代码：（在递归中用终止条件和处理逻辑）思路：这道题的思路就是用visited数组来进行标记我们访问过的岛屿，每发现一个没有被标记过的岛屿就进行对岛屿个数的统计，并对其进行访问后的标记。在代码1中，，因为在调用前就已经判断了，所以把visited的标记直接在调用前就进行处理了。在代码2中，。在深搜的开始就是判断是不是到了终止条件，如果没有，就可以进行visited的标记访问了。
代码随想录day51 99.岛屿数量 深搜 99.岛屿数量 广搜 100.岛屿的最大面积
weixin_45461296的博客
08-22 204
【代码】代码随想录day51 99.岛屿数量 深搜 99.岛屿数量 广搜 100.岛屿的最大面积。
day51 | 99、岛屿数量（ 深搜 ）99、岛屿数量 （广搜）100、岛屿的最大面积| 99、岛屿数量（ 深搜 ）99、岛屿数量 （广搜）100、岛屿的最大面积
m0_65709641的博客
08-31 344
给定一个由 1（陆地）和 0（水）组成的矩阵，计算岛屿的最大面积。岛屿面积的计算方式为组成岛屿的陆地的总数。岛屿由水平方向或垂直方向上相邻的陆地连接而成，并且四周都是水域。给定一个由 1（陆地）和 0（水）组成的矩阵，你需要计算岛屿的数量。岛屿由水平方向或垂直方向上相邻的陆地连接而成，并且四周都是水域。第一行包含两个整数 N, M，表示矩阵的行数和列数。后续 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。count = 1;后续 N 行，每行包含 M 个数字，数字为 1 或者 0。
Python||datetime.timedelta()详解，核心是minutes与minute
漫步量化
11-28 7558
datetime官方文档 from datetime import datetime,timedelta timedelta代表两个datetime之间的时间差. class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0) 所有参数可选,且默认都...
100天精通Python丨基础知识篇 —— 01、C站最全Python标准库总结
热门推荐
独木不成林，单弦不成音。
06-29 51万+
❤粉丝福利：免费下载海量【PPT模板、简历模板、学习资料】https://app.yinxiang.com/fx/13ce6bbd-f36f-4e92-be53-92dd381ed729
vue中使用day.js实现时间格式的互相转换
weixin_59895180的博客
05-09 4903
简介 Day.js 是一个轻量的处理时间和日期的 JavaScript 库，被设计用于在浏览器和Node.js中工作。本篇简单介绍了Unix时间戳和正常时间格式之间的转换
Support for specifying both a day-of-week AND a day-of-month parameter is not implemented.
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
02-08 1万+
Cron表达式，原因是：天（月的多少号）和天（周几）不能同时都为*，当有一个为*时，另一个要是？,才行。秒   分   时    天（月）   周    天（周）   年  一般年可以省略，如果是6位时，则是把年省略了。 &lt;property name="cronExpression" value="0 48 17 * * * *" /&gt; -- 报错 Support fo...
华为OD机试真题 Java 实现【开放日活动】【100%通过率】【2022.11 Q4 新题】
MISAYAONE的博客
12-17 8473
某部门开展Family Day开放日活动，其中有个从桶里取球的游戏，游戏规则如下:有N个容量一样的小桶等距排开，且每个小桶都默认装了数量不等的小球， 每个小桶装的小球数量记录在数组 bucketBallNums 中,游戏开始时，要求所有桶的小球总数不能超过 SUM，如果小球总数超过 SUM，则需对所有的小桶统一设置一个容量最大值 maxcapacity并需将超过容量最大值的小球拿出来，直至小桶里的小球数量小于 maxcapacity;请您根据输入的数据，计算从每个小桶里拿出的小球数量。
二叉树最小深度
2301_80161204的博客
09-27 466
25[0, 105]
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1277
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
904. 水果成篮
YQ20210216的博客
09-27 366
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
最新发布
m0_57859086的博客
10-01 990
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
怎么判断 aDay.DialyType = DialyData.EDialyType.EDialyType_Normal | DialyData.EDialyType.EDialyType_Weekend | DialyData.EDialyType.EDialyType_Extra; 其中一个类型2个类型
05-29
这段代码使用了位运算符“|”将三个枚举值进行了按位或运算，最终将三个枚举值合并成了一个值。因此，要判断其中是否包含某个类型，可以使用按位与运算符“&”将该类型的值与合并后的值进行按位与运算，如果结果不为0，则表示包含该类型。例如，判断是否包含EDialyType_Normal类型，可以使用以下代码： ``` if ((aDay.DialyType & DialyData.EDialyType.EDialyType_Normal) != 0) { // 包含EDialyType_Normal类型 } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值