DFS--岛屿问题

最新推荐文章于 2024-01-16 10:00:25 发布
最新推荐文章于 2024-01-16 10:00:25 发布
阅读量139 收藏
点赞数
文章标签： java leetcode
原文链接：https://leetcode-cn.com/problems/number-of-islands/solution/dao-yu-lei-wen-ti-de-tong-yong-jie-fa-dfs-bian-li-/
版权
这个博客主要探讨了四个与岛屿相关的问题，包括计算岛屿的数量、周长、最大面积以及最大人工岛。这些问题都使用了深度优先搜索（DFS）算法进行解决，通过遍历二维网格，将相邻的1（代表陆地）标记为已访问并更新结果。对于最大人工岛问题，还涉及到了使用哈希表存储岛屿面积和索引，以便计算合并后的最大岛屿面积。
摘要由CSDN通过智能技术生成

岛屿系列问题


岛屿系列DFS框架
在这里插入图片描述

L200. 岛屿数量 （Easy）

在这里插入图片描述

class Solution {
    public int numIslands(char[][] grid) {
        int num = 0 ;
        for(int i = 0 ; i < grid.length ; i++){
            for(int j = 0 ; j < grid[0].length ; j++){
                if(grid[i][j] == '1'){
                    becomeZero(grid, i, j,num);
                    num++;
                }
                 
            }
        }
        return num;
    }
    public void becomeZero(char[][] grid, int i, int j, int num){
        int nr = grid.length;
        int nc = grid[0].length;

        if (i < 0 || j < 0 || i >= nr || j >= nc || grid[i][j] == '0') {
            return;
        }
        grid[i][j] = '0';
        becomeZero(grid, i+1, j, num);
        becomeZero(grid, i-1, j , num);
        becomeZero(grid, i, j+1 , num);
        becomeZero(grid, i, j-1 , num);
    }
}

463. 岛屿的周长 （Easy）

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

class Solution {
    public int islandPerimeter(int[][] grid) {
        int n = grid.length;
        int m = grid[0].length;
        int res = 0;
        for(int i = 0; i < n ; i++){
            for(int j = 0 ; j < m; j++){
                if(grid[i][j] == 1){
                    res = dfs(grid,i,j);
                }
            }

        }
        return res;

    }
    public int dfs(int[][] grid, int i,int j){
        if(! panduan(grid,i,j)){
            return 1;
        }
        if(grid[i][j] == 0){
            return 1;
        }
        if(grid[i][j] != 1){
            return 0;
        }

        grid[i][j] = 2;
        return ( dfs(grid,i-1,j)+dfs(grid,i+1,j)+dfs(grid,i,j-1)+dfs(grid,i,j+1) );
        


    }
    public boolean panduan(int[][] grid, int i , int j){
        return ( ((i >= 0) && (i < grid.length)) && ((j >= 0) && (j < grid[0].length)) );
    }
}

695. 岛屿的最大面积 （Medium）

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

class Solution {
    public int maxAreaOfIsland(int[][] grid) {
        int n = grid.length;
        int m = grid[0].length;
        int res = 0;
        for(int i = 0 ; i < n; i++){
            for(int j = 0 ; j < m ; j++){
                if(grid[i][j] == 1){
                     res = Math.max(dfs(grid,i,j) , res);
                }
               
            }
        }
        return res;
    }
    public int dfs(int[][] grid , int r, int s){
        if(!panduan(grid, r, s)){
            return 0;
        }
        if(grid[r][s] != 1){
            return 0;
        }
        grid[r][s] = 2;
        return 1 + dfs(grid, r+1, s)
                 + dfs(grid, r-1, s)
                 + dfs(grid, r, s+1)
                 + dfs(grid, r, s-1);
    }
    public boolean panduan(int[][] grid, int r, int s){
        return ( (0<= r)&& (r < grid.length)) && ( (0<= s)&& (s < grid[0].length) ); 
    }
}
827. 最大人工岛 （Hard）

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

import java.util.Hashtable;
class Solution {
     public static int largestIsland(int[][] grid) {

        Hashtable<Integer,Integer> ht = new Hashtable<>();   //存放index和面积
        int n = grid.length;
        int m = grid[0].length;
        int res = 0;
        int index = 2;
        for(int i = 0 ; i < n; i++){
            for(int j = 0 ; j < m ; j++){
                if(grid[i][j] == 1){
                    int temp = dfs(grid,i,j,index);  //岛屿面积
                    //grid = dfsIndex(grid,i,j,index); //矩阵
                    ht.put(index,temp);
                    index++;
                    res = Math.max(res,temp);
                }
            }
        }
     if(res == 0 )  return 1 ;  
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 0) {
                    HashSet<Integer> hs = neighbor(grid ,i, j);
                    if(hs.size() < 1)  continue;
                    int count = 1; //海洋变成陆地的1
                    for(int k : hs){
                        count = ht.get(k) + count;
                        res = Math.max(count,res);
                    }
                }
            }
        }
        return res;
    }
    public static HashSet<Integer> neighbor(int[][] grid ,int r, int s) {
        HashSet<Integer> hs = new HashSet<>();
        if(panduan(grid,r,s-1) && grid[r][s-1] != 0){
            hs.add(grid[r][s-1]);
        }
        if(panduan(grid,r,s+1) && grid[r][s+1] != 0){
            hs.add(grid[r][s+1]);
        }
        if(panduan(grid,r-1,s) && grid[r-1][s] != 0){
            hs.add(grid[r-1][s]);
        }
        if(panduan(grid,r+1,s) && grid[r+1][s] != 0){
            hs.add(grid[r+1][s]);
        }
        return hs;
    }
    public static int dfs(int[][] grid , int r, int s , int index){
        if(!panduan(grid, r, s)){
            return 0;
        }
        if(grid[r][s] != 1){
            return 0;
        }
        grid[r][s] = index;
        return 1 + dfs(grid, r+1, s ,index)
                + dfs(grid, r-1, s,index)
                + dfs(grid, r, s+1,index)
                + dfs(grid, r, s-1,index);
    }
    //将岛屿赋值为2,3,4...
//    public static int[][] dfsIndex(int[][] grid , int r, int s, int index ){
//        if(!panduan(grid, r, s)){
//            return grid;
//        }
//        if(grid[r][s] != 1){
//            return grid;
//        }
//        grid[r][s] = index;
//        dfsIndex(grid, r+1, s , index);
//        dfsIndex(grid, r-1, s , index);
//        dfsIndex(grid, r, s+1, index);
//        dfsIndex(grid, r, s-1, index);
//        return grid;
//    }
    public static boolean panduan(int[][] grid, int r, int s){
        return ( (0<= r)&& (r < grid.length)) && ( (0<= s)&& (s < grid[0].length) );
    }
}
gan777777
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
12-DFS.md1111111111111111111111111111
09-21
另一个例子是关于全球变暖的问题，假设有一张地图，其中一些区域因为全球变暖而消失，我们需要统计岛屿的数量。这个问题同样可以通过DFS来解决。 ```python def count_islands(grid): def dfs(i, j): if i ...
php-leetcode题解之岛屿数量.zip
最新发布
06-08
而“岛屿数量”这个问题是LeetCode中的经典题目之一，它涉及到图论和深度优先搜索（DFS）或广度优先搜索（BFS）等算法。 首先，我们需要理解“岛屿数量”问题的背景。在这个问题中，给定一个由'0'和'1'组成的二维...
DFS递归之岛屿问题
Tom的博客
04-08 1060
三种岛屿问题的DFS模板：1.岛屿数量，2.封闭岛屿的数目，3.岛屿的最大面积
DFS遍历框架解决岛屿问题
Roxannekkk的博客
12-26 487
补充在开头 这篇题解，是我在做leetcode无意中看到的，原po将此类问题解释的非常清晰，故将其转载并添加上对应题目的解题代码，仅用做个人的学习笔记，不做任何商业用途； 引言 我们所熟悉的 DFS（深度优先搜索）问题通常是在树或者图结构上进行的。而我们今天要讨论的 DFS 问题，是在一种「网格」结构中进行的。岛屿问题是这类网格 DFS 问题的典型代表。网格结构遍历起来要比二叉树复杂一些，如果没有掌握一定的方法，DFS 代码容易写得冗长繁杂。 本文将以岛屿问题为例，展示网格类问题 DFS 通用思路，以及如
深度优先搜索（DFS）之岛屿问题
shuaishuai__的博客
07-24 1010
DFS之岛屿问题 1. 岛屿的数量 2. 岛屿的面积 3. 岛屿的周长
岛屿问题(DFS)
m0_67247641的博客
01-16 967
网格结构比二叉树结构稍微复杂一点，它其实是一种简化版的图的结构。要写好网格上的DFS遍历，我们首先要理解二叉树上的DFS遍历方法，再类比写出网格结构上的DFS遍历。由此得出，二叉树的DFS有两个要素：【访问相邻结点】和【判断 base case】。第一个要素是访问相邻结点。二叉树的相邻结点非常简单，只有左子结点和右子节点两个。二叉树本身就是一个递归定义的结构：一棵二叉树，它的左子树和右子树也是一棵二叉树。那么我们的DFS遍历只需要递归调用左子树和右子树即可。第二个要素是判断base case。
DFS-岛屿类问题解决思路
qq_40028201的博客
12-03 267
DFS-岛屿类问题解决思路 常见的背包问题有 1、岛屿个数与问题 200. 岛屿数量 2、岛屿面积问题 695. 岛屿的最大面积 3、包围问题 130. 被围绕的区域 1254. 统计封闭岛屿的数目 核心模板–漫水填充算法 /* 满水填充算法 */ int dx[4] = {0 , 0, 1, -1}; int dy[4] = {1 , -1, 0, 0}; int n; int m; int count; void dfs(vector<vector&
岛屿的周长（dfs）1
08-03
题目 "岛屿的周长（dfs）1" 是一个基于深度优先搜索（DFS）算法的编程问题，来源于 LeetCode 平台。这个问题的目标是计算给定二维网格中的岛屿的周长。岛屿是由相邻的陆地（值为1）组成的一个连通区域，而水域则用0...
go-LeetCode问题解决方案
02-08
在LeetCode中，DFS常用于解决组合问题、岛屿数量、二叉树的遍历等问题。例如，解决“岛屿数量”问题时，我们可以将网格视为一个二维图，用DFS来标记已访问过的陆地，并统计出所有岛屿的数量。 回溯法是一种试探性的...
leetcode迷宫问题-leetcode:leetcode
06-30
DFS Flood Fill相关问题 岛屿数量：由 '1'（陆地）和 '0'（水）组成的的二维网格，计算网格中岛屿的数量。 图像渲染：坐标 (sr, sc) 表示图像渲染开始的像素值（行 ，列）和一个新的颜色值 newColor，重新上色这幅...
岛屿问题-DFS
weixin_47676610的博客
06-20 328
DFS遍历框架 我们所熟悉的 DFS（深度优先搜索）问题通常是在树或者图结构上进行的。而我们今天要讨论的 DFS 问题，是在一种「网格」结构中进行的。岛屿问题是这类网格 DFS 问题的典型代表。网格结构遍历起来要比二叉树复杂一些，如果没有掌握一定的方法，DFS 代码容易写得冗长繁杂。本文将以岛屿问题为例，展示网格类问题 DFS 通用思路，以及如何让代码变得简洁。 网格类问题的 DFS 遍历方法 网格问题的基本概念 我们首先明确一下岛屿问题中的网格结构是如何定义的，以方便我们后面的讨论。网格问题是由 m×n
算法杂记-DFS岛屿问题
默语之声的博客
08-24 390
作者：nettee 链接：https://leetcode-cn.com/problems/number-of-islands/solution/dao-yu-lei-wen-ti-de-tong-yong-jie-fa-dfs-bian-li-/ 网格类问题的 DFS 遍历方法 网格问题的基本概念 我们首先明确一下岛屿问题中的网格结构是如何定义的，以方便我们后面的讨论。 网格问题是由 m×n 个小方格组成一个网格，每个小方格与其上下左右四个方格认为是相邻的，要在这样的网格上进行某种搜索。 岛屿问题是一类
DFS（二）岛屿问题合集
嘴大且吃雯的博客
01-20 1626
深度优先遍历处理岛屿问题：岛屿的周长、被围绕的区域、岛屿数量、岛屿的最大面积
【Leetcode】岛屿问题——dfs算法
小朱小朱绝不认输的博客
06-27 975
岛屿问题是dfs回溯算法中的经典问题，以下就是对岛屿问题相关的问题进行汇总。
DFS 算法秒杀五道岛屿问题
程序员小灰的博客
11-23 679
读完本文，可以去力扣解决如下题目：200.岛屿数量（中等）1254.统计封闭岛屿的数目（中等）1020.飞地的数量（中等）1905.统计子岛屿（中等）694.不同的岛屿数量（中等）岛屿问题...
岛屿(DFS)
weixin_38907184的博客
03-16 147
#include&lt;iostream&gt; #include&lt;cstring&gt; #include&lt;vector&gt; #include&lt;algorithm&gt; using namespace std; int n,m,k,ka,ks; char g[100][100]; int dx[4]={-1,1,0,0}; int dy[4]={0,0,-1,1}; v...
小白成长日记（15）--岛屿面积问题（算法设计--dfs深度优先搜索）
rangkuimei0880的博客
11-23 1924
讲真，这道题光理解题目就花了15分钟，理解完之后发现自己在刚才的15分钟里像个傻子。不多说了，贴题目。题目描述： 若海域由一个主岛和一些附属岛屿组成，海域可由一个n×n的方阵表示，矩阵中的数字表示相应主岛或岛屿的海拔：数字1～9表示陆地，数字0表示海洋。 现在程序猿儿打算在某个岛屿或主岛上探险，他的飞机将会降落在海域坐标为(x, y)的陆地上，请你计算猿儿降落点所在岛屿或主岛的面积有多大。
岛屿类问题通用解法：DFS
weixin_40578464的博客
12-29 558
题目1：200.岛屿的数量： 思路： ①遍历每一个位置，若当前位置为陆地，使用一次DFS（检查上下左右四个点），并将此次DFS中发现是陆地的位置改值，防止陷入死循环，那么使用DFS的总次数就是岛屿的数量 ②因为要检查每个位置的上下左右，因此要做范围检测，即所谓“先污染后治理”，超出范围的直接返回 代码： class Solution { public int numIslands(char[][] grid) { int rows = grid.length;//行数
岛屿数量（DFS）
ShenHang_的博客
04-20 343
很好的一道DFS，一次就通过。 class Solution { public: //一旦发现是岛屿，那么把这个岛屿上的全部1都置为0 int numIslands(vector<vector<char>>& grid) { int count = 0; for (int i = 0; i < grid.size(); i++) for (...
生成一个python版的最大岛屿问题dfs算法
03-28
以下是一个Python版的最大岛屿问题DFS算法： ```python def dfs(grid, i, j, visited): if i < 0 or i >= len(grid) or j < 0 or j >= len(grid[0]) or grid[i][j] == 0 or visited[i][j]: return 0 visited[i]...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值