（网格/岛屿问题：DFS）200. 岛屿数量、463. 岛屿的周长、695. 岛屿的最大面积、827. 最大人工岛

原创 于 2025-09-03 06:15:00 发布 · 603 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#深度优先 #算法

题目

200. 岛屿数量

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1：

输入：grid = [
[‘1’,‘1’,‘1’,‘1’,‘0’],
[‘1’,‘1’,‘0’,‘1’,‘0’],
[‘1’,‘1’,‘0’,‘0’,‘0’],
[‘0’,‘0’,‘0’,‘0’,‘0’]
]
输出：1

示例 2：

输入：grid = [
[‘1’,‘1’,‘0’,‘0’,‘0’],
[‘1’,‘1’,‘0’,‘0’,‘0’],
[‘0’,‘0’,‘1’,‘0’,‘0’],
[‘0’,‘0’,‘0’,‘1’,‘1’]
]
输出：3

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 300
grid[i][j] 的值为 ‘0’ 或 ‘1’

463. 岛屿的周长

给定一个 row x col 的二维网格地图 grid ，其中：grid[i][j] = 1 表示陆地， grid[i][j] = 0 表示水域。

网格中的格子 水平和垂直 方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。

岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长。

示例 1：

在这里插入图片描述
输入：grid = [[0,1,0,0],[1,1,1,0],[0,1,0,0],[1,1,0,0]]
输出：16
解释：它的周长是上面图片中的 16 个黄色的边

示例 2：

输入：grid = [[1]]
输出：4

示例 3：

输入：grid = [[1,0]]
输出：4

提示：

row == grid.length
col == grid[i].length
1 <= row, col <= 100
grid[i][j] 为 0 或 1

695. 岛屿的最大面积

给你一个大小为 m x n 的二进制矩阵 grid 。

岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

岛屿的面积是岛上值为 1 的单元格的数目。

计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

示例 1：

在这里插入图片描述
输入：grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]
输出：6
解释：答案不应该是 11 ，因为岛屿只能包含水平或垂直这四个方向上的 1 。

示例 2：

输入：grid = [[0,0,0,0,0,0,0,0]]
输出：0

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 50
grid[i][j] 为 0 或 1

827. 最大人工岛

思路

常规的深度优先算法如下

void dfs(TreeNode root) {
	// 判断 base case
    if (root == null) {
        return;
    }
    dfs(root.left);
    dfs(root.right);
}

网格DFS，改动点如下

  • 移动：变为上下左右四个节点移动
  • 避免重复遍历：遍历后的值要重新赋值，说明已被遍历
void dfs(int[][] grid, int r, int c) {
    // 判断 base case,如果坐标 (r, c) 超出了网格范围，直接返回
    if (!inArea(grid, r, c)) {
        return;
    }
    // 如果这个格子不是岛屿，直接返回
    if (grid[r][c] != 1) {
        return;
    }
    grid[r][c] = 2; // 将格子标记为「已遍历过」
    
    // 访问上、下、左、右四个相邻结点
    dfs(grid, r - 1, c);
    dfs(grid, r + 1, c);
    dfs(grid, r, c - 1);
    dfs(grid, r, c + 1);
}

// 判断坐标 (r, c) 是否在网格中
boolean inArea(int[][] grid, int r, int c) {
    return 0 <= r && r < grid.length 
        	&& 0 <= c && c < grid[0].length;
}

岛屿问题（网格DFS），常见的有下面几种类型的题目

  • L200. 岛屿数量 ：当遇到 grid[i][j] == '1' 时，从此点开始做深度优先搜索 dfs，岛屿数 count + 1 且在深度优先搜索中删除此岛屿（说明此岛已被遍历了）

    如果两个点是相邻的岛屿，那么这个点便会一直遍历，直到整个岛都遍历完

  • L463. 岛屿的周长 ： 可以拆分为两种类型的边

    • 网格边界：dfs 函数因为「坐标 (r, c) 超出网格范围」返回的时候，实际上就经过了一条黄色的边；
    • 海洋边界：而当函数因为「当前格子是海洋格子」返回的时候，实际上就经过了一条蓝色的
    • 值判断：
      • grid[i][j]=0：说明是海洋，返回1
      • grid[i][j]=2：说明是已经遍历的陆地，返回0
      • 当前节点超出边界，返回1
    • 返回：上下左右计算到的所有长度
      在这里插入图片描述

  • L695. 岛屿的最大面积 ：每遍历到一个格子（如果是陆地），就把面积加一

  • L827. 最大人工岛（填海造陆问题）：两遍 DFS，第一遍 DFS 遍历陆地格子，计算每个岛屿的面积并标记岛屿；第二遍 DFS 遍历海洋格子，观察每个海洋格子相邻的陆地格子

    • 第一次DFS：标记岛屿并计算面积，使用 DFS 遍历网格，给每个独立岛屿分配唯一编号（从 2 开始，避免与 0、1 冲突），并记录每个岛屿的面积。获取到最大的岛屿
    • 第二次DFS，评估水域变陆地后的最大面积：遍历所有水域（0），检查其上下左右四个方向的相邻岛屿，通过集合去重后计算连接后的总面积（相邻岛屿面积之和 + 1），更新最大面积。

      Set的add方法

      • 若集合中不存在当前添加的元素e，则将元素e加入集合，并返回true；
      • 若集合中已存在元素e（基于equals()和hashCode()判断），则不添加元素，并返回false。

      只有下面这种情况生效，所以才需要去判断set中是否有重复元素
      在这里插入图片描述
      下面的这种情况是不生效的
      在这里插入图片描述

算法

200. 岛屿数量

class Solution {
    public int numIslands(char[][] grid) {
        int count = 0;
        for (int r = 0; r < grid.length; r++) {
            for (int c = 0; c < grid[0].length; c++) {
                if (grid[r][c] == '1') {
                    dfs(grid, r, c);
                    count++;
                }
            }
        }
        return count;
    }

    private void dfs(char[][] grid, int r, int c) {
        if (!inArea(grid.length, grid[0].length, r, c)) {
            return;
        }
        if(grid[r][c] != '1'){
            return;
        }
        grid[r][c] = '2';
        dfs(grid, r + 1, c);
        dfs(grid, r, c + 1);
        dfs(grid, r - 1, c);
        dfs(grid, r, c - 1);
    }

    private boolean inArea(int maxR, int maxC, int r, int c) {
        return r >= 0 && maxR > r && c >= 0 && maxC > c;
    }
}

463. 岛屿的周长

class Solution {
    public int islandPerimeter(int[][] grid) {
        for (int r = 0; r < grid.length; r++) {
            for (int c = 0; c < grid[0].length; c++) {
                if (grid[r][c] == 1) {
                    // 其中恰好有一个岛屿
                    return dfs(grid, r, c);
                }
            }
        }
        return 0;
    }

    private int dfs(int[][] grid, int r, int c) {
        if (!inArea(grid.length, grid[0].length, r, c)) {
            return 1;
        }
        if (grid[r][c] == 0) {
            return 1;
        }
        if (grid[r][c] == 2) {
            return 0;
        }
        grid[r][c] = 2;
        return dfs(grid, r - 1, c) + dfs(grid, r, c + 1)
                + dfs(grid, r + 1, c) + dfs(grid, r, c - 1);

    }

    private boolean inArea(int maxR, int maxC, int r, int c) {
        return r >= 0 && maxR > r && c >= 0 && maxC > c;
    }
}

695. 岛屿的最大面积

class Solution {
    public int maxAreaOfIsland(int[][] grid) {
        int max = 0;
        for (int r = 0; r < grid.length; r++) {
            for (int c = 0; c < grid[0].length; c++) {
                int area = dfs(grid, r, c);
                max = Math.max(max, area);
            }
        }
        return max;
    }

    private int dfs(int[][] grid, int r, int c) {
        if (!inArea(grid.length, grid[0].length, r, c)) {
            return 0;
        }
        if (grid[r][c] != 1) {
            return 0;
        }
        grid[r][c] = 2;
        return 1 + dfs(grid, r, c - 1) + dfs(grid, r, c + 1)
                + dfs(grid, r - 1, c) + dfs(grid, r + 1, c);
    }

    private boolean inArea(int maxR, int maxC, int r, int c) {
        return r >= 0 && maxR > r
                && c >= 0 && maxC > c;
    }
}

827. 最大人工岛

class Solution {
    public int largestIsland(int[][] grid) {
        List<Integer> area = new ArrayList<>();
        int n = grid.length;
        int ans = 0;
        for (int r = 0; r < n; r++) {
            for (int c = 0; c < n; c++) {
                int a = dfs(grid, r, c, area.size() + 2);
                area.add(a);
                ans = Math.max(a, ans);
            }
        }
        if (area.isEmpty()) {
            return 1;
        }
        // 上 下 左 右
        int[][] dirs = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };
        Set<Integer> set = new HashSet<>();
        
        for (int r = 0; r < n; r++) {
            for (int c = 0; c < n; c++) {
                if (grid[r][c] != 0) {
                    continue;
                }
                // 每次遍历水域的上下左右节点都清空一遍
                set.clear();
                int newArea = 1;
                for (int[] dir : dirs) {
                    int x = c + dir[1];
                    int y = r + dir[0];
                    if (inArea(n, y, x)
                            && grid[y][x] != 0 && set.add(grid[y][x])) {
                        newArea += area.get(grid[y][x] - 2);
                    }
                }
                ans = Math.max(ans, newArea);
            }
        }
        return ans;

    }

    private int dfs(int[][] grid, int r, int c, int id) {
        if (!inArea(grid.length, r, c)) {
            return 0;
        }
        if (grid[r][c] != 1) {
            return 0;
        }
        grid[r][c] = id;
        return 1 + dfs(grid, r, c - 1, id) + dfs(grid, r, c + 1, id)
                + dfs(grid, r - 1, c, id) + dfs(grid, r + 1, c, id);

    }

    private boolean inArea(int n, int r, int c) {
        return r >= 0 && n > r && c >= 0 && n > c;
    }
}
【LeetCode】463. 岛屿的周长、695. 岛屿的最大面积、200. 岛屿的个数
qq_43109561的博客
02-03 472
463. 岛屿的周长 给定一个包含 0 和 1 的二维网格地图，其中 1 表示陆地 0 表示水域。 网格中的格子水平和垂直方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。 岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛...
（c++）leetcode.200——岛屿数量
Alannah的个人学习记录
03-26 845
原题地址：https://leetcode-cn.com/problems/number-of-islands/ 给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 示例： 输入：grid = [ [“1”,“1”,“1”,“1”,“0”], [“1”,“1”,“0”,“1”,“0”], [“1”,“1”,“0”,“0”,“0”], [“0”,“0
岛屿的周长(思路很重要，很经典)
小武在岳阳吖！的博客
10-30 705
题目:给定一个包含 0 和 1 的二维网格地图，其中 1 表示陆地 0 表示水域。 网格中的格子水平和垂直方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。 岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长。 示例输入: [[0,1,0,0], [1,1,1,0], [0,1,0,0], [1,1,0,0]] 输出: 16
【LeetCode】岛屿（周长、数量、最大面积、封闭岛屿数）
热门推荐
像写诗一样优雅地写代码~
01-13 1万+
【LeetCode】岛屿（周长、面积、数量） 岛屿的周长★ LeetCode463. 岛屿的周长 【题目】给定一个 row x col 的二维网格地图 grid ，其中：grid[i][j] = 1 表示陆地， grid[i][j] = 0 表示水域。 网格中的格子 水平和垂直 方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。 岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方
【Leetcode】岛屿问题（数量，周长，面积）
YaoYee_21的博客
08-14 376
DFS四邻域感染岛屿，遍历数组
岛屿类-网格类问题-DFS | 力扣463. 岛屿的周长
比特的一天
06-23 742
思路参考： 岛屿类-网格类问题-DFS | 力扣200. 岛屿数量 本文讲解463. 岛屿的周长问题，属于常见的岛屿类-网格类问题 本题使用DFS的思想 其实还有暴力递归的思路，属于比较巧妙的一种 目录题目 示例思路 一 DFS代码思路 二 递归计算代码 题目 示例 思路 一 DFS 思路参考： 岛屿类-网格类问题-DFS | 力扣200. 岛屿数量 代码 class Solution { public: int islandPerimeter(vector<vector<
LeetCode 463. 岛屿的周长(dfs, 容斥定理, 卷积运算)
Wu_yongtao的博客
10-31 540
力扣的一道简单题(题解被玩出了花样) 463. 岛屿的周长 文章目录力扣的一道简单题(题解被玩出了花样)题目描述示例解法一: dfs(深度优先搜索)解法二: 统计上边和左边, 然后*2解法三: 容斥定理大佬的解法: 卷积运算 题目描述 给定一个包含 0 和 1 的二维网格地图，其中 1 表示陆地 0 表示水域。 网格中的格子水平和垂直方向相连（对角线方向不相连）。 整个网格被水完全包围，但其中恰好有一个岛屿 （或者说，一个或多个表示陆地的格子相连组成的岛屿）。 岛屿中没有“湖”（“湖” 指水域在岛屿内
岛屿的周长（dfs）1
08-03
题目 "岛屿的周长（dfs）1" 是一个基于深度优先搜索（DFS）算法的编程问题，来源于 LeetCode 平台。这个问题的目标是计算给定二维网格中的岛屿的周长。岛屿是由相邻的陆地（值为1）组成的一个连通区域，而水域则用0...
LeetCode题目笔记——463. 岛屿的周长，/C++
一个苦逼研究僧的博客
10-10 287
LeetCode463.岛屿的周长，迭代法一次循环解决，打败89%。
LeetCode 例题精讲 | 12 岛屿问题：网格结构中的 DFS
nettee的专栏
04-15 721
本期例题为 LeetCode「岛屿问题」系列：LeetCode 463. Island Perimeter 岛屿的周长（Easy）LeetCode 695. Max Area of Is...
Leetcode200. 岛屿数量
12-21
岛屿数量 给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/number-of-islands 示例 1: 输入: 11110 11010 11000 00000 输出: 1 示例 2: 输入: 11000 11000 00100 00011 输出: 3 解释: 每座岛屿只能由水平和/或竖直方向上相邻的陆地连接而成。 方法一：
leetcode岛屿面积-LeetCode:LeetCode题目集
06-30
leetcode岛屿面积 LeetCode 排序算法 冒泡（BubbleSort） 快排 归并 搜索算法 回溯 递归 剪枝 CoinChange DFS（Deep First Search）深度优先搜索 岛屿的最大面积（MaxAreaOfIsland） BFS（Breath First Search）广度优先搜索 图论 最短路径 最小生成树 动态规划（dp） 最长上升子序列（lengthOfLIS） 基础技巧 分治 贪心 二分 倍增
leetcode【中等】200、岛屿数量 / 463、岛屿周长 / 695、岛屿的最大面积
qq_40707462的博客
03-12 212
给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。 一堆1连在一起算一个岛屿，岛屿的上下左右为0或者边界 思路：dfs 主函数中遍历， 当遇到 grid[i][j] == '1' 时，从此点开始 dfs，岛屿数 count + 1 dfs： 目前指针(i, j)，从 (i, j) 向此点的上下左右 (i+1,j),(i-1,j),(i,j+1),(i,j-1) 做深度搜索。遇到边界（数组边界+遇到水）则终止； 同时，执行 grid[i][j] = '0'，以免之后重复
[leetcode]Number of islands最大岛屿数
weixin_43564373的博客
11-15 316
原题描述： Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may...
岛屿数量、岛屿面积，岛屿周长
weixin_42693876的博客
09-02 337
1、BFS class Solution { public: int numIslands(vector<vector<char>>& grid) { int nr = grid.size(); if (!nr) return 0; int nc = grid[0].size(); int num_islands = 0; for (int r = 0; r < nr; ++r)
LeetCode—200.岛屿数量(Number of Islands)——分析及代码（C++）
江南土豆的博客
11-16 725
LeetCode—200.岛屿数量[Number of Islands]——分析及代码[C++] 一、题目 二、分析及代码 1. 深度优先搜索 （2）代码 （3）结果 三、其他 一、题目 给定一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。 示例 1: 输入: 11110 11010 11000 00000 输出: 1 示例 2: 输入: 11000 11000 0010
Leetcode岛屿数量(C++)
CT_WJ的博客
07-23 1141
题目描述： 给定一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。 样例1： 输入: 11110 11010 11000 00000 输出: 1 样例2： 输入: 11000 11000 00100 00011 输出: 3 解题思路： 要求：没有被访问过且值为‘...
[C++] LeetCode 200. 岛屿的个数
沧海漂游的博客
09-06 2549
题目 给定一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。 示例 1: 输入: 11110 11010 11000 00000 输出: 1 示例 2: 输入: 11000 11000 00100 ...
C++——岛屿数量
一抹阳光的博客
05-26 2163
在遍历数组的过程中，若当前位置上的字符为“1”，首先将岛屿数量加一，然后将该位置的字符设为“0”并搜索该位置的上下左右位置，若为1，则置“0”并继续搜索直到四周都为0，为止，继续遍历重复此操作。 说明（因为连着的陆地算一个岛屿，因此当我们遍历到“1”时，需要搜索1周围是否存在“1”可以连成一个岛屿，直到找不到相连的陆地为止，同时将这些搜索过的置为“0”，避免后面遍历的时候重复计算。 代码如下： class Solution { public: /** * 判断岛屿数量 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

?abc!

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值