• 代码随想录刷题|LeetCode 62.不同路径 63. 不同路径 II

    62.不同路径

    题目链接：力扣

    思路

            数组变成二维的了，在原理上和爬楼梯比较像
            得出某个格子从start的路径，是从上方的格子和左方的格子得到的，这就是二维意义上的
            爬楼梯某层的方法是从前一层到达和从前两层到达得到的，这就是一维意义上的

            爬楼梯的初始化是一个点，初始化第一层台阶和第二层台阶
            爬格子的初始化是一条线，初始化上边和下边

    1、定义dp数组的含义

            因为格子的状态是二维的，所以每个格子的位置是【i，j】，那么dp[i][j]就代表，在从start到【i，j】位置上的路径为dp[i][j]        

    2、状态递推公式

            那么dp[i][j] 可以从两种途径获得，一种是从上方，dp[i-1,j]；另一种是从左方，dp[i,j-1]

            所以 dp[i][j] = dp[i-1][j] + dp[i][j-1]

            注意区分这里是记录到达这个格子的不同路径，而不是记录到达这个格子的不同步数，这个要区分清楚

    3、初始化

            对于初始化，应该初始化这个地图的上边和下边，这两边是没有办法通过递推公式获取到，那为什么要复制1呢，因为从start到达上方和下方的格子都只是只有一种情况，题目要求只能向上和向下，没有其他路径可以到达        

    4、遍历方式

            因为是获取上方和下方的结果得到当前结果，所以只能是从左向右遍历，从上向下遍历

     

    不同路径

    1. class Solution {
    2.     public int uniquePaths(int m, int n) {
    3.  
    4.         // 定义dp数组
    5.         int[][] dp = new int[m][n];
    6.  
    7.         // 初始化数组
    8.         for (int i = 0; i < m; i++) {
    9.             dp[i][0] = 1;
    10.         }
    11.         for (int j = 0; j < n; j++) {
    12.             dp[0][j] = 1;
    13.         }
    14.  
    15.         // 遍历数组，填充dp数组
    16.         for (int i = 1; i < m; i++) {
    17.             for (int j = 1; j < n; j++) {
    18.                 dp[i][j] = dp[i-1][j] + dp[i][j-1];
    19.             }
    20.         }
    21.  
    22.         return dp[m-1][n-1];
    23.     }
    24. }

    63. 不同路径 II

    题目链接：力扣

    思路

            这道题目整体上和上面的62差不多，重点是在对障碍物的处理上

    边界上的障碍物：

            初始化的时候，如果遇到障碍物，就不能向后初始化了，因为障碍是走不过去的，这是一个重要的细节，这一步错了，后面就完蛋了

    起点和终点的障碍物：

            起点或者终点有障碍物的时候，就不能得出最终的路径了，返回0

    中间的障碍物：

            中间的障碍物是很好处理的，如果遇到障碍物，就跳过就可以

    不同路径||

    1. class Solution {
    2.     public int uniquePathsWithObstacles(int[][] obstacleGrid) {
    3.         // 获取表格的长度和宽度
    4.         int m = obstacleGrid.length;
    5.         int n = obstacleGrid[0].length;
    6.  
    7.         // 如果障碍在start或者是end上，路径为0，返回0
    8.         if (obstacleGrid[0][0] == 1 || obstacleGrid[m-1][n-1] == 1) {
    9.             return 0;
    10.         }
    11.     
    12.         // 定义dp数组
    13.         int[][] dp = new int[m][n];
    14.  
    15.         // 初始化dp数组，注意边界上的障碍
    16.         for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) {
    17.             dp[i][0] = 1;
    18.         }
    19.         for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) {
    20.             dp[0][j] = 1;
    21.         }
    22.  
    23.         // 遍历dp数组，填充dp数组
    24.         for (int i = 1; i < m; i++) {
    25.             for (int j = 1; j < n; j++) {        
    26.                 if (obstacleGrid[i][j] != 1) {
    27.                     dp[i][j] = dp[i-1][j] + dp[i][j-1];
    28.                 }
    29.             }
    30.         }
    31.  
    32.         return dp[m-1][n-1];
    33.     }
    34. }

  • 相关阅读:
    在Cisco设备上配置接口速度和双工
    # SpringBoot 集成 Netty
    Hive中常用SerDe介绍
    EXP 一款 Java 插件化热插拔框架
    MIT6.830-lab5-B+ Tree Index(数据库的索引B+树的搜索、插入、删除窃取、删除合并)
    【python】【logging】python如何使用logging模块，一个完美的logging模块
    堆栈的类型及特点
    [docker]笔记-portainer的安装
    Scala 基础 （五）：面向对象（上篇）
    RHCE8 资料整理（三）
  • 原文地址：https://blog.csdn.net/m0_62575233/article/details/127945425