代码随想录算法训练营第 50 天 | 99. 岛屿数量、100. 岛屿的最大面积

原创 已于 2025-11-30 20:53:25 修改 · 659 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #图 #数据结构 #java

于 2025-11-28 23:51:58 首次发布

99. 岛屿数量

题目链接

思路：
遍历每个地方，如果该处为陆地，且未访问过。将结果加 1.并将该处所连的陆地全部标记为已访问。

方法一：
dfs ——先格子赋值为 true，再进入 dfs 函数。（dfs 隐式终止条件）
（实质是遍历相邻的 4 个节点）

import java.util.*;

public class Main {
    public static int[][] dir = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();

        int[][] grid = new int[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                grid[i][j] = sc.nextInt();
            }
        }

        int result = 0;
        boolean[][] visited = new boolean[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1 && !visited[i][j]) {
                    result++;
                    visited[i][j] = true; // 先赋值为 true，再进入 dfs 函数
                    dfs(grid, visited, i, j);
                }
            }
        }

        System.out.println(result);
    }

    public static void dfs(int[][] grid, boolean[][] visited, int x, int y) {
        for (int i = 0; i < 4; i++) {
            int nextX = dir[i][0] + x;
            int nextY = dir[i][1] + y;
            if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
                continue;
            }
            if (grid[nextX][nextY] == 1 && !visited[nextX][nextY]) { // 必须是未访问过的陆地，递归终止条件隐含在此
                visited[nextX][nextY] = true; // 先赋值为 true，再进入 dfs 函数
                dfs(grid, visited, nextX, nextY);
            }
        }
    }
}

方法二：
dfs ——判断完终止条件后，再赋值为 true。（dfs 显式终止条件）
（实质是从当前节点开始）

import java.util.*;

public class Main {
    public static int[][] dir = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();

        int[][] grid = new int[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                grid[i][j] = sc.nextInt();
            }
        }

        int result = 0;
        boolean[][] visited = new boolean[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1 && !visited[i][j]) {
                    result++;
                    dfs(grid, visited, i, j);
                }
            }
        }

        System.out.println(result);
    }

    public static void dfs(int[][] grid, boolean[][] visited, int x, int y) {
        if (grid[x][y] == 0 || visited[x][y]) { // 当不是陆地或者已经访问过就退出
            return;
        }
        
        visited[x][y] = true; // 判断完终止条件后，再赋值为 true
        
        for (int i = 0; i < 4; i++) {
            int nextX = dir[i][0] + x;
            int nextY = dir[i][1] + y;
            if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
                continue;
            }
            dfs(grid, visited, nextX, nextY); // 不用判断陆地和访问，直接 dfs
        }
    }
}

方法三：
bfs

重点：队列刚一放进去元素，visited 数组就要立马标记为 true。

import java.util.*;

public class Main {
    public static int[][] dir = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();

        int[][] grid = new int[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                grid[i][j] = sc.nextInt();
            }
        }

        int result = 0;
        boolean[][] visited = new boolean[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1 && !visited[i][j]) {
                    result++;
                    bfs(grid, visited, i, j);
                }
            }
        }

        System.out.println(result);
    }

    public static void bfs(int[][] grid, boolean[][] visited, int x, int y) {
        Queue<int[]> queue = new ArrayDeque<>();
        queue.offer(new int[] {x, y});
        visited[x][y] = true; // 队列刚一放进去元素，visited 数组就要立马标记为 true

        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            for (int i = 0; i < 4; i++) {
                int nextX = dir[i][0] + cur[0];
                int nextY = dir[i][1] + cur[1];

                // 判断未越界
                if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
                    continue;
                }

                // 判断为陆地，且未访问过
                if (grid[nextX][nextY] == 1 && !visited[nextX][nextY]) {
                    queue.offer(new int[] {nextX, nextY});
                    visited[nextX][nextY] = true; // 队列刚一放进去元素，visited 数组就要立马标记为 true
                }
            }
        }
    }
}

优化：
dfs 或 bfs 时，可以只搜右下的格子。

100. 岛屿的最大面积

题目链接

思路和上题几乎一样，dfs 和 bfs 皆可，只需要把统计岛屿数量改成统计岛屿最大面积。

方法一：
dfs ——先格子赋值为 true，再进入 dfs 函数。（dfs 隐式终止条件）
（实质是遍历相邻的 4 个节点）

import java.util.*;

public class Main {
    public static int[][] dir = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
    public static int count; // 统计单块区域面积

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();

        int[][] grid = new int[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                grid[i][j] = sc.nextInt();
            }
        }

        int result = 0; // 统计最大面积
        boolean[][] visited = new boolean[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1 && !visited[i][j]) {
                    count = 1; // 初始化为 1
                    visited[i][j] = true; // 先赋值为 true，再进入 dfs 函数
                    dfs(grid, visited, i, j);
                    result = Math.max(result, count);
                }
            }
        }

        System.out.println(result);
    }

    public static void dfs(int[][] grid, boolean[][] visited, int x, int y) {
        for (int i = 0; i < 4; i++) {
            int nextX = dir[i][0] + x;
            int nextY = dir[i][1] + y;
            if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
                continue;
            }
            if (grid[nextX][nextY] == 1 && !visited[nextX][nextY]) { // 必须是未访问过的陆地，递归终止条件隐含在此
                count++; // 先 ++，再进入 dfs
                visited[nextX][nextY] = true; // 先赋值为 true，再进入 dfs 函数
                dfs(grid, visited, nextX, nextY);
            }
        }
    }
}

方法二：
dfs ——判断完终止条件后，再赋值为 true。（dfs 显式终止条件）
（实质是从当前节点开始）

import java.util.*;

public class Main {
    public static int[][] dir = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
    public static int count; // 统计单块区域面积

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();

        int[][] grid = new int[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                grid[i][j] = sc.nextInt();
            }
        }

        int result = 0; // 统计最大面积
        boolean[][] visited = new boolean[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1 && !visited[i][j]) {
                    count = 0; // 因为是先进入 dfs 再 count++，所以这里要赋值为 0
                    dfs(grid, visited, i, j);
                    result = Math.max(result, count);
                }
            }
        }

        System.out.println(result);
    }

    public static void dfs(int[][] grid, boolean[][] visited, int x, int y) {
        if (grid[x][y] == 0 || visited[x][y]) { // 当不是陆地或者已经访问过就退出
            return;
        }
        count++; // 先进入 dfs 再 count++
        visited[x][y] = true; // 先进入该格子再赋值为 true

        for (int i = 0; i < 4; i++) {
            int nextX = dir[i][0] + x;
            int nextY = dir[i][1] + y;
            if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
                continue;
            }
            dfs(grid, visited, nextX, nextY); // 不用判断陆地和访问，直接 dfs
        }
    }
}

方法三：
以上两种 dfs 方法二合一。进入格子后立即赋为 true

import java.util.*;

public class Main {
    public static int[][] dir = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
    public static int count; // 统计单块区域面积

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();

        int[][] grid = new int[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                grid[i][j] = sc.nextInt();
            }
        }

        int result = 0; // 统计最大面积
        boolean[][] visited = new boolean[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1 && !visited[i][j]) {
                    count = 1; // 初始化为 1
                    dfs(grid, visited, i, j);
                    result = Math.max(result, count);
                }
            }
        }

        System.out.println(result);
    }

    public static void dfs(int[][] grid, boolean[][] visited, int x, int y) {
        visited[x][y] = true; // 进入后立即设为 true
        
        for (int i = 0; i < 4; i++) {
            int nextX = dir[i][0] + x;
            int nextY = dir[i][1] + y;
            if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
                continue;
            }
            if (grid[nextX][nextY] == 1 && !visited[nextX][nextY]) { // 必须是未访问过的陆地，递归终止条件隐含在此
                count++; // 先 ++，再进入 dfs
                dfs(grid, visited, nextX, nextY);
            }
        }
    }
}
代码随想录算法训练营第三天| 203.移除链表元素 707.设计链表| 206.反转链表
kkksij的博客
10-28 1173
建议： 本题最关键是要理解 虚拟头结点的使用技巧，这个对链表题目很重要。思路：1.直接使用原来的链表进行删除操作。 2.设置一个虚拟头结点在进行删除操作题目链接：. - 力扣（LeetCode）视频链接：手把手带你学会操作链表 | LeetC de：203.移除链表元素_哔哩哔哩_bilibili文章链接：手把手带你学会操作链表 | LeetCode：203.移除链表元素_哔哩哔哩_bilibili具体实现：定义一个cur = head 的结点，遍历链表，每次遍历时 cur.val 和
代码随想录算法训练营第51天 | 99.岛屿数量 深搜、99.岛屿数量 广搜、100.岛屿的最大面积
Athenaand的博客
09-10 271
第51天，继续加油。
ranger管mysql_Apache Ranger：统一授权管理框架
weixin_31971727的博客
02-04 664
Apache Ranger 是一个用在 Hadoop 平台上并提供操作、监控、管理综合数据安全的框架。Ranger 的愿景是在 Apache Hadoop 生态系统中提供全面的安全性。 目前，Apache Ranger 支持以下 Apache 项目的细粒度授权和审计：Apache HadoopApache HiveApache HBaseApache StormApache KnoxApache ...
代码随想录算法训练营第50天｜99. 岛屿数量、100. 岛屿的最大面积
qq_32756029的博客
10-21 188
代码随想录算法训练营第50天｜99. 岛屿数量、100. 岛屿的最大面积 深度优先搜索递归，广度优先搜索队列。
代码随想录算法训练营第51天| 99. 岛屿数量、100. 岛屿的最大面积
2301_76253115的博客
02-20 363
这题比较简单，在99的基础上稍作修改，不统计岛屿个数，统计岛屿面积，最后输出最大值就可以。要注意的是调用bfs的时候要把space初始值设置为1，因为进入的那一块是面积的第一部分。本题思路，是用遇到一个没有遍历过的节点陆地，计数器就加一，然后把该节点陆地所能遍历到的陆地都标记上。那么如何把节点陆地所能遍历到的陆地都标记上呢，就可以使用 DFS，BFS或者并查集。是否小于 0，即是否超出了地图的上边界。是否小于 0，即是否超出了地图的左边界。卡码题目链接：​​​​​​​。学习链接：​​​​​​​。
代码随想录算法训练营第51天|99. 岛屿数量、100. 岛屿的最大面积
Yinems的博客
08-20 466
在 Python 中，global 关键字用于在函数内部声明一个变量是全局变量，而不是函数内部的局部变量。使用 global 可以使得函数内部对变量的修改反映到函数外部的全局范围。本题思路，是用遇到的一个没有遍历过的节点陆地，计数器加一，然后把该节点陆地所能遍历到的陆地都标记上。在遇到标记过陆地节点和海洋节点都直接跳过，这样计数器就是最终岛屿的数量。只要节点加入队列就代表走过，就需要标记，而不是从队列拿出来的时候再标记走过。这道题在上一题的基础上需要统计岛屿的面积。
代码随想录算法训练营第51天 | 99.岛屿数量 深搜 广搜 100.岛屿的最大面积
ohnoooo9的博客
05-19 213
岛屿数量深搜岛屿数量深搜。
代码随想录算法训练营第50天| 99.岛屿数量 深搜 ，99.岛屿数量 广搜 ，100.岛屿的最大面积
weixin_44647325的博客
10-21 327
注意深搜的两种写法，熟练掌握这两种写法 以及 知道区别在哪里，才算掌握的深搜。
代码随想录算法训练营第51天 | 99. 岛屿数量 深搜、99. 岛屿数量 广搜、100.岛屿的最大面积
2301_76968221的博客
11-25 247
【代码】代码随想录算法训练营第51天 | 99. 岛屿数量 深搜、99. 岛屿数量 广搜、100.岛屿的最大面积。
代码随想录算法训练营第一天 - 704. 二分查找
05-08
代码随想录算法训练营第一天 - 704. 二分查找
代码随想录算法训练营第一天- 977.有序数组的平方 ， 209.长度最小的子数组，59.螺旋矩阵II
10-12
代码随想录算法训练营第一天- 977.有序数组的平方 ， 209.长度最小的子数组，59.螺旋矩阵II
代码随想录算法训练营第三天 || 203.移除链表元素 707.设计链表 206.反转链表（双指针 or 递归）
2402_83930684的博客
09-06 761
本文总结了链表操作的三个经典题目解法：203题移除链表元素提供了不设虚拟头节点和引入虚拟头节点两种方法；707题设计链表实现了完整的链表操作API；206题反转链表展示了双指针和递归两种解法。关键点在于正确处理头节点/虚拟头节点，以及准确维护指针关系。易错点包括循环条件判断、指针初始化和size维护等，建议通过绘制链表示意图和测试边界条件来验证代码正确性。
Leetcode 68 搜索插入位置 | 寻找比目标字母大的最小字母
im_AMBER的博客
12-04 706
你的错误逻辑正确逻辑找到 target 时返回 mid-1找到 target 时，继续向右查找（因为需要「大于」target 的最小字符）target <letters [mid] 时，mid 是候选，需保留，right=mid（左闭右开）或不立即排除 mid循环结束直接返回 letters [0]循环结束后，先判断 left 是否越界：越界则返回 letters [0]，否则返回 letters [left]初始right的取值与「越界判断」不匹配；
欧几里得距离算法-相似度
weixin_45609702的博客
12-04 30
本文介绍了一个计算欧几里得距离的Java方法。该方法接收两个Double数组作为输入，通过计算对应元素差值的平方和再开方，返回两个数组之间的欧几里得距离值。当输入数组长度不一致时，方法会返回0作为默认值。欧几里得距离算法常用于比较两个数组之间的相似度，是数据分析和机器学习中的基础距离度量方法。
dfs|mask^翻转
一个人知道自己为什么而活，他就能够接收任何一种生活
11-30 160
注意到：灯泡状态周期是6。
[优选算法专题十.哈希表 ——NO.55~57 两数之和、判定是否互为字符重排、存在重复元素]
2401_83386596的博客
12-03 554
两数之和问题的最优解法采用哈希表实现O(n)时间复杂度，通过存储元素值与下标的映射关系，快速查找互补值。字符重排判定问题通过单哈希数组统计字符出现次数，先加后减并实时校验，确保字符种类和数量完全一致。存在重复元素问题使用哈希集合检测重复元素，遍历数组时检查元素是否已存在于集合中。三种解法均利用哈希结构优化查找效率，将时间复杂度从暴力解法的O(n²)降至O(n)，是典型空间换时间策略的工业级实现。
【剑斩OFFER】算法的暴力美学——数青蛙
最新发布
就业知识博客
12-04 206
力扣1419题：数青蛙
红包分配算法的严格数学理论与完整实现
12-03 642
红包分配问题可以严格定义为： 定义 1.1（红包分配问题）: 给定总金额 M>0M > 0M>0 和参与人数 n∈N+n \in \mathbb{N}^+n∈N+，分配函数 f:{1,2,...,n}→R+f: \{1, 2, ..., n\} \rightarrow \mathbb{R}^+f:{1,2,...,n}→R+ 需要满足：设 Ω\OmegaΩ 为样本空间，F\mathcal{F}F 为事件域，PPP 为概率测度： 1.2.2 随机变量性质 定义随机变量 XiX_iXi​ 表示第 iii 个人获
简单多源BFS问题
MiauwYuki的博客
12-03 98
简单多源BFS问题
代码随想录算法训练营第五天
02-17
### 关于代码随想录算法训练营第五天学习内容 #### 动态规划入门 动态规划是一种通过把原问题分解为相对简单的子问题的方式来求解复杂问题的方法。在第五天的学习中，重点在于理解并掌握动态规划的核心概念及其应用。 #### 解决斐波那契数列问题 斐波那契数列是一个经典的例子来介绍动态规划的思想。对于给定的n值，计算第n项斐波那契数值可以采用自底向上的方法构建解决方案[^1]： ```python def fib(n): if n <= 0: return 0 elif n == 1: return 1 dp = [0] * (n + 1) dp[1] = 1 for i in range(2, n + 1): dp[i] = dp[i - 1] + dp[i - 2] return dp[n] ``` 此实现方式避免了重复计算相同的子问题，从而提高了效率。 #### 攀爬楼梯问题 另一个典型的应用场景是攀爬楼梯问题，假设每次可以选择走一步或两步，则到达第n阶的不同路径总数也可以利用动态规划解决: ```python def climbStairs(n): if n == 1 or n == 2: return n dp = [0] * (n + 1) dp[1], dp[2] = 1, 2 for i in range(3, n + 1): dp[i] = dp[i - 1] + dp[i - 2] return dp[-1] ``` 上述两个案例展示了如何运用动态规划技巧有效地解决问题，并且强调了状态转移方程的重要性以及边界条件处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值