动态规划系列

Chrison_mu

已于 2022-09-12 15:19:05 修改

阅读量384

点赞数

分类专栏： Java基础题型 Chrison刷题记录文章标签：动态规划算法 leetcode

于 2022-09-11 18:32:20 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_52875110/article/details/126807713

版权

Chrison刷题记录同时被 2 个专栏收录

24 篇文章

订阅专栏

Java基础题型

4 篇文章

订阅专栏

在LeetCode上刷动态规划刷到崩溃，因为一个=没过AC找了半天毛病，本来都不打算写blog了，但是这么痛苦还是记录一下这几天对动态规划的浅浅的理解，以及刷题感悟。毕竟动态规划这个系列的问题还是很重要的，彻底理解还是需要很多的时间，不能光一边掰苞米，一边扔苞米

首先适用于动态规划的场景：将一个规模比较大的问题划分为k个子问题，但是这k个子问题中有重叠，这也是动态规划区别于分治算法的一个很重要的部分

首先分析题目的规模--->dp[i][j]数组下标的含义--->递推公式--->dp数组的初始化--->遍历顺序（比如有些把二维数组压缩成一维数组的话，如果从前往后遍历会出现，有些数被放进背包里两次）

先说一个刚准备利用动态规划的时候刷到的题目

给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标。

跳跃游戏

错误版本，不要再犯，当时想的时候就当跳格子，二维数组里面，每一行去找他能跳到最远的位置，然后遍历最后一行，如果有数，且之前没有任何一列全部为0，就是能跳到最后。

class Solution{
    public boolean canJump(int[] nums) {
        int len=nums.length;
        if(len==1){
            return true;
        }
        int[][]dp=new int[len][len];
        for(int j=0;j<len;j++){
            int cnt=0;
            for(int i=j;i<len;i++){
               dp[i][j]=cnt;
               cnt++;
                if(cnt>nums[j]){
                    break;
                }
            }
        }
        boolean flag=false;
        for(int i=0;i<len;i++){
            if(dp[len-1][i]!=0){
                flag=true;
            }else {
                for (int k=0;k<len;k++){
                    flag=dp[k][i]!=0?true:false;
                    if(flag==true){
                        break;
                    }
                }
            }
        }
        return flag;
    }
}

然后怎么调都是无法AC，这个错误的主要原因是我不是先找dp的递推关系式，而是通过个例去推普遍，最后也无法找到适合所有情况的边界值判断方法。

这道题最佳方案是通过一个max值去维护当前位置于i的时候能跳到的最远位置，一直维护x+nums[x]，

class Solution {
    public boolean canJump(int[] nums) {
         if(nums.length<=1){
            return true;
        }
        int max=0;
        for(int i=0;i<nums.length-1;i++){
            if(i<=max) {
                max=max>i+nums[i]?max:i+nums[i];
                if (max >= nums.length - 1) {
                    return true;
                }
            }
        }
        return false;
    }
}

ok现在正式开始动态规划刷题的记录

1. 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

每次能爬一个或者两阶，所以dp[i]代表爬到第i层台阶一共有的方法数

dp[i]=dp[i-1]+dp[i-2]，代表第i层可以从第i-1层跨一步上来，也可以从第i-2层跨两步上来

初始化，爬一阶楼梯，dp[1]=1;爬两层，跨一步跨两步dp[2]=2;

class Solution {
    public int climbStairs(int n) {
        int[] dp=new int[n+1];
        
            dp[1]=1;dp[2]=2;
            dp[1]=1;dp[2]=2;
            for(int i=3;i<n+1;i++){
                dp[i]=dp[i-1]+dp[i-2];
            }
        return dp[n];
    }
}

然后把题目改变为

一次爬一阶，二阶....m阶。（之后细说代码）

2.斐波那契数列

这道题与上面题思路很像，不作赘述

class Solution {
    public int fib(int n) {
        if(n==0) return 0;
        if(n==1) return 1;
        int[] dp=new int[n+1];
         dp[0]=0;dp[1]=1;
        for(int i=2;i<dp.length;i++){
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
}

3.使用最小花费爬楼梯

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

请你计算并返回达到楼梯顶部的最低花费。

输入：cost = [10,15,20]
输出：15
解释：你将从下标为 1 的台阶开始。
- 支付 15 ，向上爬两个台阶，到达楼梯顶部。
总花费为 15 。

来源：力扣（LeetCode）

花费最小的代价爬上台阶，当然第i阶台阶可以从i-1或者i-2上面过来。ok那么现在再来看一下这个例，你可以从下标为0或者为1 的地方往上爬楼梯，但是我们并不知道到底从哪一个，那么我们或许可以不可以逆过来，就当我们是从最后需要到达的楼梯顶部往下在下楼梯

如果把这道题理解为下楼梯的话，我们站在顶部往下走，所以我们可以从i-1或者i-2处上去，所以最小的花费就是i-1和i-2处的dp比较下来较小的值

$dp[i]=min\begin{bmatrix} dp[i-1]& dp[i-2] \end{bmatrix}+value[i]$

此处value[i]即cost[i]

然后考虑一下初始化，如果你走0，或者走1处都是选择他们本身的值

class Solution {
    public int minCostClimbingStairs(int[] cost) {
      int dp[]=new int[cost.length];
      if(cost.length==0){
          return cost[0];
      }
      if(cost.length==1){
          return cost[0]<cost[1]?cost[0]:cost[1];
      }
      dp[0]=cost[0];dp[1]=cost[1];
      for(int i=2;i<dp.length;i++){
          dp[i]=Math.min(dp[i-1],dp[i-2])+cost[i];
      }
      return dp[cost.length-1]<dp[cost.length-2]?dp[cost.length-1]:dp[cost.length-2];
    }
}

4.不同路径

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

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

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

每次向下或者向右，我们记录一个二维数组dp[i][j]为位于i,j位置时有多少种走法

$dp[i][j]=dp[i-1][j]+dp[i][j-1]$

所以递推公式我们也能轻易得到，然后是数组的初始化。最上面和最下面的行列肯定只有直走的一种走法故，初始化为1.

注意二维数组的下标，从0行开始的话，new int[m][n],而最右下角是dp[m-1][n-1]

class Solution {
   public int uniquePaths(int m, int n) {
        int[][] dp=new int[m][n];
        for(int i=0;i<m;i++){
            dp[i][0]=1;
        }
        for(int j=0;j<n;j++){
            dp[0][j]=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-1][n-1];
    }
}

5.不同路径II

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

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

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

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

好现在题目更变了，变成有障碍物的情况，当然如果没有障碍物的话 $dp[i][j]=dp[i-1][j]+dp[i][j-1]$

dp[i][j]处肯定还是这个递推公式，但是如果那边有了呢，即他是“1”，所以我们不管你之前从哪儿来，这个地方肯定不能走了，所以都置为0.

初始化的时候就考虑到这个情况，本来是可以从一而终走到第一行第一列的最后的。我们就去判断从哪边开始有了障碍物，障碍物之后的肯定是不可以走了，就都置为0.

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m=obstacleGrid.length;
        int n=obstacleGrid[0].length;
        int[][] dp=new int[m][n];
        if(obstacleGrid[0][0]==1){//判断机器人一开始在的位置能不能走
            return 0;
        }
        dp[0][0]=1;
        for(int i=1;i<m;i++){
            if (obstacleGrid[i][0]==1){
                dp[i][0]=0;
            }else {
                dp[i][0]=dp[i-1][0];
//沿承前一个格子，前一个格子能走他也能走，前一个不能他也不行
            }
        }
        for(int j=1;j<n;j++){
            if (obstacleGrid[0][j]==1){
                dp[0][j]=0;
            }else {
                dp[0][j]=dp[0][j-1];
            }
        }
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                if(obstacleGrid[i][j]==1){
                    dp[i][j]=0;
                }else {
                    dp[i][j]=dp[i-1][j]+dp[i][j-1];
                }
            }
        }
        return dp[m-1][n-1];
    }
}

6.分隔等和子集

给你一个 只包含正整数 的非空数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

在讲等和子集之前，我们先讲一讲0-1背包

0-1背包顾名思义，你有一个容量固定的背包，每个物品你只有拿和不拿两种选项，请你给出你能得到最大价值

例如

	weight	value
物品0	1	15
物品1	3	20
物品2	4	30

dp[i][[j]表示在0-i个物品中选择去装容量为j的包里面能装的最大价值

故0-i个物品里面我们选不选i物品呢？

1.不装i物品的话， $dp[i][j]=dp[i-1][j]$ (意思就是我不拿i物品我就在0~i-1的物品里面选取能拿的最大值）

2.装物品i的话， $dp[i][j]=dp[i-1][j-weight[i]]+value[i]$ ,我要拿物品i了，我就要在我容量为j的包里面空出他的位置， $j-weight[i]$ ,然后这个就是我们剩下的容量，我们肯定要在这剩下的容量里面再去拿东西最多，我们拿了i了之后能拿东西的范围也就是0~i-1

故递推公式 $dp[i][j]=max\begin{Bmatrix} dp[i-1][j] ,&dp[i-1][j-weight[i]]+value[i] \end{Bmatrix}$

初始化，第一列背包容量为0肯定什么也拿不了就是0了，第一行只能拿物品0就看物品0的重量是多少了

没有再写这个的代码了，粘一下一开始学算法的时候完成老师作业的代码

用动态规划法求如下0/1背包问题的最优解：有5个物品，其重量分别为（3,2,1,4,5），价值分别为
（25,20,15,40,50），背包容量为6，写出求解过程

语言当时用的是c++；最后还把dp数组打印了一下，而且比较max值的语句是可以被优化的。当然二维数组还可以被优化为一维，这个就容后再议，先把二维练熟了再去考虑滚动数组的方案

ok，说到这里我们再来看一下这道LeetCode题，

我们要将一个非空数组，计算其总和然后把其分为两个和相等的数组，数组里面有多少元素无所谓只要有就行。所以首先如果nums数组的和为奇数，直接return false。

如果是偶数的话，我们就相当于我们有容量为sum/2的包，我们要在这个数组里面选择元素（每个元素还只能选一次）来把我们的包填满，能填满的话剩下的元素自动就去了下一个背包。

递推公式： $dp[i][j]=max\begin{Bmatrix} dp[i-1][j], &dp[i-1][j-nums[i]]+nums[i] \end{Bmatrix}$

class Solution {
     public boolean canPartition(int[] nums) {
        int sum=0;
        for(int i=0;i<nums.length;i++){
            sum+=nums[i];
        }
        if(sum%2!=0){
            return false;
        }
        sum/=2;
       int[][] dp=new int[nums.length][sum+1];
       for(int i=0;i<nums.length;i++){
           dp[i][0]=0;
       }
       for(int j=1;j<=sum;j++){
           if(j-nums[0]>=0){
               dp[0][j]=nums[0];
           }
       }
       for(int i=1;i<nums.length;i++){
           for(int j=1;j<=sum;j++){
               if(j-nums[i]>0){
                   dp[i][j]=Math.max(dp[i-1][j],dp[i-1][j-nums[i]]+nums[i]);
               }else {
                   dp[i][j] = dp[i - 1][j];
               }
           }
       }
//       for(int[] date:dp){
//           System.out.println(Arrays.toString(date));
//       }
        if(dp[nums.length-1][sum]==sum){
            return true;
        }
        return false;
    }
}

7.最后一块石头的重量II

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。

每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。

输入：stones = [2,7,4,1,8,1]
输出：1
解释：
组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]，
组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]，
组合 2 和 1，得到 1，所以数组转化为 [1,1,1]，
组合 1 和 1，得到 0，所以数组转化为 [1]，这就是最优值。

来源：力扣（LeetCode）

粉碎的话，是不是还像上一题一样，就是把这些拆成几乎差不多的两堆，就看最后有多少会多出来。

我们依旧用一个容量为sum/2的背包，去尽可能装最重的石头，然后最后 $\left | dp[len-1][sum/2]*2-sum\right |$ 就是我们要求的留到最后的最小的石头重量

class Solution {
   public int lastStoneWeightII(int[] stones) {
        //粉碎石头，大概率找到平均值最后进行粉碎
        int sum=0;
        for(int i=0;i<stones.length;i++){
            sum+=stones[i];
        }
        int temp=sum/2;
        int dp[][]=new int[stones.length][temp+1];
        for(int i=0;i<stones.length;i++){
            dp[i][0]=0;
        }
        for(int j=1;j<=temp;j++){
            if(j-stones[0]>=0){
                dp[0][j]=stones[0];
            }
        }
        for(int i=1;i<stones.length;i++){
            for(int j=1;j<=temp;j++){
                if(j-stones[i]>=0){
                    dp[i][j]=Math.max(dp[i-1][j],dp[i-1][j-stones[i]]+stones[i]);
                }
                else {
                    dp[i][j]=dp[i-1][j];
                }
            }
        }
        // for(int[] cur:dp){
        //     System.out.println(Arrays.toString(cur));
        // }
        return Math.abs(dp[stones.length-1][temp]*2-sum);
    }
}

$j-nums[i]>=0$ 注意这个的=号