0
点赞
收藏
分享

微信扫一扫

GO 的 Web 开发系列(六)—— 遍历路径下的文件

zhyuzh3d 03-05 23:00 阅读 4

目录

引言:

例题1:不同路径

例题2:不同路径II

例题3:礼物的最⼤价值

例题4:下降路径最⼩和

例题5:最小路径和

结语:


引言:

在学习完动态规划斐波那契数列模型后,相信大家对动态规划已经有了一定的了解,下面我们继续深入学习动态规划的路径问题,我们一般的解题步骤还是1. 状态表示,2.状态转移方程,3.初始化,4.填表顺序,5.返回值。在写代码时一定要把这5步考虑清楚再写代码,写代码的步骤为1.创建 dp表2.初始化3.填表4.返回值。

例题1:不同路径

链接:不同路径

题目简介:

一个机器人位于一个 m x n 网格的左上角 (起始点在下图中标记为 “Start” )。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角(在下图中标记为 “Finish” )。

问总共有多少条不同的路径?

解法(动态规划):

1. 状态表示:

对于这种「路径类」的问题,我们的状态表⽰⼀般有两种形式:

(1)从[i, j] 位置出发到终点有几种路径。

(2)从起始位置出发,到达[i, j] 位置有几种路径。

本题我们选择第二种,dp[i][j] 表示:⾛到[i, j] 位置处,⼀共有多少种⽅式。

2.状态转移方程

简单分析⼀下。如果dp[i][j] 表⽰到达[i, j] 位置的⽅法数,那么到达[i, j] 位置之 前的⼀⼩步,有两种情况:

(1)从[i, j] 位置的上⽅( [i - 1, j] 的位置)向下⾛⼀步,转移到[i, j] 位置

(2)从[i, j] 位置的左⽅( [i, j - 1] 的位置)向右⾛⼀步,转移到[i, j] 位置。

由于我们要求的是有多少种⽅法,因此状态转移⽅程就呼之欲出了: dp[i][j] = dp[i - 1] [j] + dp[i][j - 1] 。

3.初始化

使用辅助结点 。

注意点:(1)辅助结点⾥⾯的值要「保证后续填表是正确的」(2)下标的映射关系。在本题中,「添加⼀⾏」,并且「添加⼀列」后,只需将dp[0][1] 的位置初始化为1 即可。

4.填表顺序

根据「状态转移⽅程」的推导来看,填表的顺序就是「从上往下」填每⼀⾏,在填写每⼀⾏的时候 「从左往右」。

5.返回值

根据「状态表⽰」,我们要返回dp[m][n](添加了一个辅助节点) 的值 。

代码如下:

动态规划编写代码的步骤比较固定,上面那5步是想好思路,下面这4步是编写代码的步骤。

class Solution {
    public int uniquePaths(int m, int n) {
        //1.创建dp表
        //2.初始化
        //3.填表
        //4.返回值
        int[][] dp = new int[m + 1][n + 1];
        dp[0][1] = 1;
        for(int i = 1;i <= m;i++){
            for(int j = 1;j <= n;j++){
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m][n];
    }
}

时间复杂度:O(n * m)

空间复杂度:O(n * m)

例题2:不同路径II

链接:不同路径II

题目简介:

一个机器人位于一个 m x n 网格的左上角 (起始点在下图中标记为 “Start” )。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角(在下图中标记为 “Finish”)。

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径?

网格中的障碍物和空位置分别用 1 和 0 来表示。

 解法(动态规划):

本题是例题一的进阶版,但是两题的解题步骤是类似的不同的地方在于状态转移方程。[i - 1, j] 与[i, j - 1] 位置都是可能有障碍的,此时从上⾯或者左边是不可能到达[i, j] 位置的,也就是说,此时的⽅法数应该是0。由此我们可以得出⼀个结论,只要这个位置上「有障碍物」,那么我们就不需要计算这个位置上的值,直接让它等于0即可。

代码如下:

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        //1.创建dp表
        //2.初始化
        //3.填表
        //4.返回值
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[][] dp = new int[m + 1][n + 1];
        dp[0][1] = 1;
        for(int i = 1;i <= m;i++){
            for(int j = 1;j <= n;j++){
                if(obstacleGrid[i - 1][j - 1] == 1){
                    dp[i][j] = 0;
                }else{
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }
            }
        }
        return dp[m][n];
    }
}

时间复杂度:O(n * m)

空间复杂度:O(n * m)

例题3:礼物的最⼤价值

链接:礼物的最⼤价值

题目简介:

现有一个记作二维矩阵 frame 的珠宝架,其中 frame[i][j] 为该位置珠宝的价值。拿取珠宝的规则为:

  • 只能从架子的左上角开始拿珠宝
  • 每次可以移动到右侧或下侧的相邻位置
  • 到达珠宝架子的右下角时,停止拿取

注意:珠宝的价值都是大于 0 的。除非这个架子上没有任何珠宝,比如 frame = [[0]]

解法(动态规划):

1. 状态表示:

dp[i][j] 表⽰:⾛到[i, j] 位置处,此时的最⼤价值。

2.状态转移方程

对于dp[i][j] ,我们发现想要到达[i, j] 位置,有两种⽅式:

(1)从[i, j] 位置的上⽅[i - 1, j] 位置,向下⾛⼀步,此时到达[i, j] 位置能 拿到的礼物价值为dp[i - 1][j] + grid[i][j] .

(2)从[i, j] 位置的左边[i, j - 1] 位置,向右⾛⼀步,此时到达[i, j] 位置能 拿到的礼物价值为dp[i][j - 1] + grid[i][j].

最终dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) + grid[i][j] 。

3.初始化

添加辅助节点

4.填表顺序

填表的顺序是「从上往下填写每⼀⾏」,「每⼀⾏从左往右」。

5.返回值

返回dp[m][n]的值

代码如下:

class Solution {
    public int jewelleryValue(int[][] frame) {
        //1.创建dp表
        //2.初始化
        //3.填表
        //4.返回值
        int m = frame.length;
        int n = frame[0].length;
        int[][] dp = new int[m + 1][n + 1];
        for(int i = 1;i <= m;i++){
            for(int j = 1;j <=n;j++){
                dp[i][j] = Math.max(dp[i - 1][j],dp[i][j - 1]) + frame[i - 1][j - 1];
            }
        }
        return dp[m][n];
    }
}

时间复杂度:O(n * m)

空间复杂度:O(n * m)

例题4:下降路径最⼩和

链接:下降路径最⼩和

题目简介:

给你一个 n x n 的 方形 整数数组 matrix ,请你找出并返回通过 matrix 的下降路径  最小和 。

下降路径 可以从第一行中的任何元素开始,并从每一行中选择一个元素。在下一行选择的元素和当前行所选元素最多相隔一列(即位于正下方或者沿对角线向左或者向右的第一个元素)。具体来说,位置 (row, col) 的下一个元素应当是 (row + 1, col - 1)(row + 1, col) 或者 (row + 1, col + 1) 。

解法(动态规划):

1. 状态表示:

dp[i][j] 表⽰:到达[i, j] 位置时,所有下降路径中的最⼩和。

2.状态转移方程

对于普遍位置[i, j] ,根据题意得,到达[i, j] 位置可能有三种情况:

(1)从正上⽅[i - 1, j] 位置转移到[i, j] 位置.

(2)从左上⽅[i - 1, j - 1] 位置转移到[i, j] 位置;

  (3)   从右上⽅[i - 1, j + 1] 位置转移到[i, j] 位置;

由于我们要的是最小的于是 dp[i][j] = min(dp[i - 1][j], min(dp[i - 1][j - 1], dp[i - 1][j + 1])) + matrix[i][j] 。

3.初始化

辅助节点

在本题中,需要「加上⼀⾏」,并且「加上两列」。所有的位置都初始化为⽆穷⼤,然后将第⼀⾏ 初始化为0即可。

4.填表顺序

表的顺序是从上往下。

5.返回值

返回dp表中最后⼀⾏的最⼩值。

代码如下:

class Solution {
    public int minFallingPathSum(int[][] matrix) {
        //1.创建dp表
        //2.初始化
        //3.填表
        //4.返回值
        int m = matrix.length;//y
        int n = matrix[0].length;//x
        int[][] dp = new int[m + 1][n + 2];
        //辅助节点
        for(int i = 0;i <= m;i++){
            dp[i][0] = Integer.MAX_VALUE;
            dp[i][n + 1] = Integer.MAX_VALUE;
        }
        for(int i = 1;i <= n;i++){
            dp[m][i] = Integer.MAX_VALUE;
        }
        for(int i = m - 1;i >= 0;i--){
            for(int j = 1;j <= n;j++){
                int min = Math.min(Math.min(dp[i + 1][j - 1],dp[i + 1][j]),dp[i + 1][j + 1]);
                if(min == Integer.MAX_VALUE){
                    min = 0;
                }
                dp[i][j] = matrix[i][j - 1] + min;
            }
        }
        int key = dp[0][1];
        for(int i = 1;i <= n;i++){
            if(key > dp[0][i]){
                key = dp[0][i];
            }
        }
        return key;
    }
}

时间复杂度:O(n * m)

空间复杂度:O(n * m)

例题5:最小路径和

链接:最⼩路径和

题目简介:

给定一个包含非负整数的 m x n 网格 grid ,请找出一条从左上角到右下角的路径,使得路径上的数字总和为最小。

说明:每次只能向下或者向右移动一步。

解法(动态规划):

1. 状态表示:

dp[i][j] 表⽰:到达[i, j] 位置处,最⼩路径和是多少。

2.状态转移方程

简单分析⼀下。如果dp[i][j] 表⽰到达到达[i, j] 位置处的最⼩路径和,那么到达 [i, j] 位置之前的⼀⼩步,有两种情况:

(1)从[i - 1, j] 向下⾛⼀步,转移到[i, j] 位置;

(2)从[i, j - 1] 向右⾛⼀步,转移到[i, j] 位置。

由于到[i, j] 位置两种情况,并且我们要找的是最⼩路径,因此只需要这两种情况下的最⼩值,再加上 [i, j] 位置上本⾝的值即可。故最终结果为:dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]。

3.初始化

辅助节点

在本题中,「添加⼀⾏」,并且「添加⼀列」后,所有位置的值可以初始化为⽆穷⼤,然后让 dp[0][1] = dp[1][0] = 0 即可。如下图所示:

4.填表顺序

「从上往下」填每⼀⾏,每⼀⾏「从左往右」。

5.返回值

返回的结果是dp[m][n] 。

代码如下:

class Solution {
    public int minPathSum(int[][] grid) {
        //1.创建dp表
        //2.初始化
        //3.填表
        //4.返回值
        int m = grid.length;//y
        int n = grid[0].length;//x
        int[][] dp = new int[m + 1][n + 1];
        for(int i = 2;i <= n;i++){
            dp[0][i] = Integer.MAX_VALUE;
        }
        for(int i = 2;i <= m;i++){
            dp[i][0] = Integer.MAX_VALUE;
        }
        for(int i = 1;i <= m;i++){
            for(int j = 1;j <= n;j++){
                dp[i][j] = Math.min(dp[i - 1][j],dp[i][j - 1]) + grid[i - 1][j - 1];
            }
        }
        return dp[m][n];

    }
}

时间复杂度:O(n * m)

空间复杂度:O(n * m)

结语:

其实写博客不仅仅是为了教大家,同时这也有利于我巩固自己的知识点,和一个学习的总结,由于作者水平有限,对文章有任何问题的还请指出,接受大家的批评,让我改进,如果大家有所收获的话还请不要吝啬你们的点赞收藏和关注,这可以激励我写出更加优秀的文章。

举报

相关推荐

0 条评论