【模板总结】二维网格、 岛屿问题 总结

已于 2022-08-01 20:38:07 修改
阅读量147 收藏
点赞数
文章标签： java 深度优先 算法
于 2022-07-06 11:08:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bijian0530/article/details/125634557
版权

模板套用
大家发现 都是套用一个模板

剑指 Offer II 105. 岛屿的最大面积

在这里插入图片描述

class Solution {
    public int maxAreaOfIsland(int[][] grid) {
        int ans = 0;
        for(int i = 0; i < grid.length; i++){
            for(int j = 0; j < grid[0].length; j++){
                if(grid[i][j] == 1){
                    ans = Math.max(ans, dfs(grid, i, j));
                }
            }
        }
        return ans;
    }
    public int dfs(int[][] grid, int x, int y){
        if(x < 0 || y < 0 || x >= grid.length || y >= grid[0].length || grid[x][y] == 0){
            return 0;
        }
        grid[x][y] = 0;
        int sum = 1;
        sum += dfs(grid, x + 1, y);
        sum += dfs(grid, x - 1, y);
        sum += dfs(grid, x, y - 1);
        sum += dfs(grid, x, y + 1);
        return sum;
    }
}


   class Solution {
      int[][] grid;
      boolean[][] used;
      int m;
      int n;
      int[][] DIRECTION = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};

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

      private int dfs(int i, int j) {
         used[i][j] = true;
         int ans = 1;
         for (int[] d : DIRECTION) {
            int x = i + d[0];
            int y = j + d[1];
            if(x >= 0 && x < m && y >= 0 && y < n && used[x][y] == false && grid[x][y] == 1){
               ans += dfs(x, y);
               used[x][y] = true;
            }
         }
         return ans;
    }
}

200. 岛屿数量

在这里插入图片描述

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

   private void dfs(char[][] grid, int i, int j) {
      if(i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == '0'){
         return;
      }
      grid[i][j] = '0';
      dfs(grid, i + 1, j);
      dfs(grid, i - 1, j);
      dfs(grid, i, j + 1);
      dfs(grid, i, j - 1);
   }

   class Solution {
      int m;
      int n;
      char[][] grid;
      boolean[][] used;
      int[][] DIRECTION = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};

      public int numIslands(char[][] grid) {
         this.m = grid.length;
         this.n = grid[0].length;
         this.grid = grid;
         used = new boolean[m][n];
         int ans = 0;
         for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
               if (used[i][j] == false && grid[i][j] == '1') {
                  dfs(i, j);
                  ans++;
               }
            }
         }
         return ans;
      }

      private void dfs(int i, int j) {
         used[i][j] = true;
         int ans = 1;
         for (int[] d : DIRECTION) {
            int x = i + d[0];
            int y = j + d[1];
            if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == '1' && used[x][y] == false){
               used[x][y] = true;
               dfs(x, y);
            }
         }
      }

   }

面试题 16.19. 水域大小

在这里插入图片描述

   public int[] pondSizes(int[][] land) {
      List<Integer> res = new ArrayList<>();
      for (int i = 0; i < land.length; i++) {
         for (int j = 0; j < land[0].length; j++) {
            if (land[i][j] == 0) {
               int count = dfs(land, i, j);
               res.add(count);
            }
         }
      }
      int[] ans = new int[res.size()];
      for (int i = 0; i < ans.length; i++) {
         ans[i] = res.get(i);
      }
      return ans;
   }

   private int dfs(int[][] land, int i, int j) {
      if (i < 0 || i >= land.length || j < 0 || j >= land[0].length || land[i][j] != 0) {
         return 0;
      }
      land[i][j] = -1;
      int ans = 1;
      ans += dfs(land, i - 1, j);
      ans += dfs(land, i + 1, j);
      ans += dfs(land, i, j - 1);
      ans += dfs(land, i, j + 1);
      ans += dfs(land, i - 1, j + 1);
      ans += dfs(land, i - 1, j - 1);
      ans += dfs(land, i + 1, j + 1);
      ans += dfs(land, i + 1, j - 1);
      return ans;
   }

   class Solution {
      int m;
      int n;
      int[][] land;
      boolean[][] used;
      int[][] DIRECTION = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}, {1,1}, {1, -1}, {-1, 1}, {-1, -1}};
      public int[] pondSizes(int[][] land) {
         this.m = land.length;
         this.n = land[0].length;
         this.land = land;
         this.used = new boolean[m][n];
         List<Integer> list = new ArrayList<>();
         for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
               if(land[i][j] == 0 && used[i][j] == false){
                  int ans = dfs(i, j);
                  list.add(ans);
               }
            }
         }
         int[] res = new int[list.size()];
         for (int i = 0; i < list.size(); i++) {
            res[i] = list.get(i);
         }
         return res;
      }

      private int dfs(int i, int j) {
         used[i][j] = true;
         int ans = 1;
         for (int[] d : DIRECTION){
            int x = i + d[0];
            int y = j + d[1];
            if(x >= 0 && x < m && y >= 0 && y < n && used[x][y] == false && land[x][y] == 0){
               ans += dfs(x, y);
            }
         }
         return ans;
      }
   }

剑指 Offer 12. 矩阵中的路径

在这里插入图片描述

这里需要回溯

class Solution {
   public boolean exist(char[][] board, String word) {
      char[] str = word.toCharArray();
      for (int i = 0; i < board.length; i++) {
         for (int j = 0; j < board[0].length; j++) {
            if(dfs(board, str, i, j, 0)){
               return true;
            }
         }
      }
      return false;
   }

   private boolean dfs(char[][] board, char[] str, int i, int j, int index) {
      if(i < 0 || i >= board.length || j < 0 || j >= board[0].length || board[i][j] != str[index]){
         return false;
      }
      if(index == str.length - 1){
         return true;
      }
      board[i][j] = ' ';
      boolean res = dfs(board, str, i + 1, j, index + 1) || dfs(board, str, i - 1, j, index + 1)
              || dfs(board, str, i, j + 1, index + 1) ||dfs(board, str, i, j - 1, index + 1);
      board[i][j] = str[index];
      return res;
   }
}

2328. 网格图中递增路径的数目

在这里插入图片描述

   int[][] cache;
   long mod = (long) (1e9 + 7);

   public int countPaths(int[][] grid) {
      cache = new int[grid.length][grid[0].length];
      for (int i = 0; i < cache.length; i++) {
         Arrays.fill(cache[i], -1);
      }
      long ans = 0;
      for (int i = 0; i < grid.length; i++) {
         for (int j = 0; j < grid[0].length; j++) {
            ans = (ans + dfs(grid, i, j)) % mod;
         }
      }
      return (int) ans;
   }
   private long dfs(int[][] grid, int i, int j) {
      if (cache[i][j] != -1) {
         return cache[i][j];
      }
      if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length) {
         return 0;
      }
      long ans = 1;
      int m = grid.length;
      int n = grid[0].length;
      if (i < m - 1 && grid[i + 1][j] > grid[i][j]) {
         ans = (ans + dfs(grid, i + 1, j)) % mod;
      }

      if (i >= 1 && grid[i - 1][j] > grid[i][j]) {
         ans = (ans + dfs(grid, i - 1, j)) % mod;
      }
      if (j >= 1 && grid[i][j - 1] > grid[i][j]) {
         ans = (ans + dfs(grid, i, j - 1)) % mod;
      }
      if (j < n - 1 && grid[i][j + 1] > grid[i][j]) {
         ans = (ans + dfs(grid, i, j + 1)) % mod;
      }
      cache[i][j] = (int) ans;
      return ans;
   }

class Solution {
   int m;
   int n;
   int[][] grid;
   int[][] arr;
   long mod = (long) (1e9 + 7);
   int[][] DIRECTION = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};
   public int countPaths(int[][] grid) {
      this.arr = new int[grid.length][grid[0].length];
      this.grid = grid;
      for (int[] arr1 : arr){
         Arrays.fill(arr1, -1);
      }
      this.m = grid.length;
      this.n = grid[0].length;
      long ans = 0;
      for (int i = 0; i < grid.length; i++) {
         for (int j = 0; j < grid[0].length; j++) {
            ans = (ans + dfs(i, j)) % mod;
         }
      }
      return (int) ans;
   }

   private long dfs(int i, int j) {
      if(arr[i][j] != -1){
         return arr[i][j];
      }
      long ans = 1;
      for (int[] d : DIRECTION){
         int x = i + d[0];
         int y = j + d[1];
         if(x >= 0 && x < m && y >= 0 && y < n && grid[i][j] < grid[x][y]){
            ans = (ans + dfs(x, y)) % mod;
         }
      }
      arr[i][j] = (int) ans;
      return ans;
   }
}

转载标明 本网址 ~ ！ https://blog.csdn.net/bijian0530/article/details/125634557

bijian0530
关注
岛屿问题模板C++
zhaoxiaoba的博客
05-19 1917
题目列表leetcode 200. 岛屿数量leetcode 463 岛屿的周长leetcode 695. 岛屿的最大面积leetcode 934.最短的桥leetcode 1254. 统计封闭岛屿的数目leetcode 827. 最大人工岛 leetcode 200. 岛屿数量 题目 给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 实例 输入:
回溯法解决二维平面搜索问题
qq_20110551的博客
08-02 553
回溯法解决二维平面搜索问题 LeetCode 79 给定一个二维网格和一个单词，找出该单词是否存在于网格中。 单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。 示例: board = [ ['A','B','C','E'], ['S','F','C','S'], ['A','D',...
岛屿数量（高效解法）
桀客
10-24 543
给定一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。 示例 1: 输入: 11110 11010 11000 00000 输出: 1 示例 2: 输入: 11000 11000 00100 00011 输出: 3 遍历二维数组，遇到值为1的位置，就从该位置开始深搜，深搜过程中，遇到值为1，则将1变为0。 public int numIs
leecode岛屿问题
隔壁老陈的博客
05-24 600
一、leetcode200. 岛屿数量  　　给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 输入：grid = [ [“1”,“1”,“1”,“1”,“0”], [“1”,“1”,“0”,“1”,“0”], [“1”,“1”,“0”,“0”,“0”], [“0”,“0”,“0”,“0”,“0”] ] 输出：1 思路：岛屿问题都
简单BFS 模板题 PTA 岛屿数量
weixin_62248351的博客
10-23 488
给你一个由 1（陆地）和 0（水）组成的n*m的二维网格，请你计算网格中岛屿的数量num。岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。例如此为两个岛屿此外，你可以假设该网格的四条边均被水包围。
leetcode200岛屿问题模板
BlackNite21的博客
04-02 202
在 LeetCode 中，「岛屿问题」是一个系列系列问题，比如： L200. 岛屿数量 （Easy） 463. 岛屿的周长 （Easy） 695. 岛屿的最大面积 （Medium） 827. 最大人工岛 （Hard） 我们所熟悉的 DFS（深度优先搜索）问题通常是在树或者图结构上进行的。而我们今天要讨论的 DFS 问题，是在一种「网格」结构中进行的。岛屿问题是这类网格 DFS 问题的典型代表。网格结构遍历起来要比二叉树复杂一些，如果没有掌握一定的方法，DFS 代码容易写得冗长繁杂。 本文将以岛屿问题为例，展
算法-由岛屿问题引出网格dfs通用解法
weixin_43868966的博客
03-12 236
文章目录问题一、从二叉树到网格二、本题思路 问题 一、从二叉树到网格 网格实际上是一类特殊的图【简化版】，如果没有技巧很啰嗦 二叉树dfs解题模板： void dfs(TreeNode root) { if (root == null) return; dfs(root.left); dfs(root.right); } 算法主体分为两个部分： (1)baseline：即root == null (2)访问邻接点: 二叉树的邻接点很简单，就是左右子树，且子树不存在循环引用，..
【深度优先遍历】经典岛屿问题汇总
qq_41959920的博客
05-10 2123
岛屿系列算法问题是经典的面试高频题，岛屿系列题目的核心考点就是用 DFS/BFS 算法遍历二维数组。如何在二维矩阵中使用 DFS 搜索呢？ 我们可以把二维矩阵中的每个点看做一个节点，这个节点的上下左右四个位置就是相邻节点，那么整个矩阵就可以抽象成一幅网状的「图」结构，二维矩阵的搜索问题就变成了从某个点出发，向上下左右四个方向进行深度搜索的问题。
岛屿类问题(DFS、BFS、DSU)
5lovetutu的专栏
02-19 669
目录 1. 深度优先搜索（DFS） 1.1 模板 1.2 避免重复 1.3 图解 1.4 实现 2. 广度优先搜索（BFS） 2.1 实现 3. 并查集（DSU） 3.1 思路 3.1.1 图解 3.1.2 初始化数组 QuickUnion() 3.1.3 查找所属集合 find() 3.1.4 合并 union() 3.2 实现 在 leetCode 中，「岛屿问题」是一个系列系列问题。 我们首先明确一下岛屿问题中的网格结构是如何定义的，以方便我们后面的讨论。 网格问题是
leetcode.200：岛屿数量
janyoo的博客
06-23 129
给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 示例 1: 输入: 11110 11010 11000 00000 输出: 1 示例 2: 输入: 11000 11000 00100 00011 输出: 3 解释: 每座岛屿只能由水平和/或竖直方向上相邻的陆地连接而成。 通过次数119,195提交次数240,500 来源：力扣（LeetCode）
leetcode--深度优先（DFS）概念总结和经典题目解析汇总
数据挖掘+大数据研发+算法学习
12-31 1162
ing
Leetcode岛屿数量(C++)
CT_WJ的博客
07-23 1063
题目描述： 给定一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。 样例1： 输入: 11110 11010 11000 00000 输出: 1 样例2： 输入: 11000 11000 00100 00011 输出: 3 解题思路： 要求：没有被访问过且值为‘...
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 411
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 745
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 514
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 787
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1192
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 320
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
二维正交曲线网格生成技术在水质模拟中的应用
"基于MO的二维正交曲线网格生成技术及其应用" 本文主要探讨了基于Lax-Moore（L-M）理论的二维正交曲线网格生成技术，并介绍了其在水质模拟中的应用。正交曲线网格在水文学、水动力学以及环境科学等领域有着重要的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值