【算法练习】LeetCode-动态规划学习计划

@u@

已于 2022-02-06 20:08:38 修改

阅读量434

点赞数

分类专栏：算法练习文章标签： leetcode 算法动态规划

于 2022-01-26 12:02:37 首次发布

本文链接：https://blog.csdn.net/Mxeron/article/details/122665986

版权

算法练习专栏收录该内容

41 篇文章 6 订阅

订阅专栏

题目来自：https://leetcode-cn.com/study-plan/dynamic-programming/?progress=nc4eyhc

爬楼梯（简单）

在这里插入图片描述

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

使用最小花费爬楼梯（简单）（爬楼梯进阶版本）

在这里插入图片描述
注意，cost的最后一个元素不是楼顶，还需要爬一次才到楼顶， 还需要注意状态转移方程和base case。

状态转移方程：
$d p [n] = m i n (d p [n - 1] + c o s t [n - 1], d p [n - 2] + c o s t [n - 2])$
初始情况：因为题目说可以从0、1下标的台阶开始，所以它们的花费=0。

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        // min(dp[n-1]+cost[n-1], dp[n-2]+cost[n-2])
        int n = cost.length;
        int[] dp = new int[n + 1];
        // base case
        dp[0] = 0;
        dp[1] = 0;
        // 迭代所有状态
        for (int i = 2; i <= n; i++) {
            dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
        }
        return dp[n];
    }
}

打家劫舍（中等）

在这里插入图片描述
思考这么一个问题，对于某一号房间，具有什么状态？ 很简单就是抢和不抢， 所以就可以写出状态转移方程：
$d p [n] = m a x (d p [n - 1], d p [n - 2] + n u m s [n])$
选择不抢，那么旁边的就可以抢；选择抢，那么旁边的就不可以抢，比较抢和不抢的价值，即可得出最终答案。

初始情况，第1号房间就是其本身的价值（因为就它一间房子，只有抢了价值才最大），第二号房间就要判断抢第1号房间，还是抢第2号房间，选择价值更大的房间来抢。

注意题目中1号房间的下标是0。

class Solution {
    public int rob(int[] nums) {
        // 对于每间房屋有两种状态：抢（加上这家的价值）、不抢（那就看旁边一家的价值）
        // dp[n] = max(dp[n-1], dp[n-2] + nums[n])
        // 注意题目中下标0记录的是一号房间的价值
        int n = nums.length;
        if (n == 1) {
            return nums[0];
        }
        if (n == 2) {
            return Math.max(nums[0], nums[1]);
        }
        int[] dp = new int[n + 1];
        // base case
        // 房间号从 1 开始
        dp[1] = nums[0];
        // 2号房间分为：抢1号房间、不抢1号房间
        dp[2] = Math.max(nums[0], nums[1]);
        // 遍历所有状态
        for (int i = 3; i <= n; i++) {
            // nums[i - 1]是因为nums的1号房间从下标0开始
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i - 1]);
        }
        return dp[n];
    }
}

打家劫舍Ⅱ（中等）

在这里插入图片描述
和上一道题不同在于，1号房间和最后一号房间连接在一起了，想一想这会导致什么问题？
连接在一起了说明，1号房间一旦被抢，最后一号房间就不能被抢；而1号房间没被抢，最后一号房间可能被抢（注意只是可能，因为最后一号房间可以抢或者不抢）。上一道题1号房间只有一种状态，但本题1号房间有两种状态，必须要确定下1号房间的状态，才能确定后续房间的状态。

所以，我们可以把1号房间的状态分成两种情况进行讨论：抢1号、不抢1号，因为两种情况下dp数组的初始化是不同的。最后再比较两中状态下，总的抢劫钱数，取最大的。

抢1号：那么后续步骤和上一题一样，但是最后第n号房间要注意，dp[n]只能等于dp[n-1]，因为n号房间是不能抢的！！！

不抢1号：dp[1]=0，dp[2]=nums[2-1]，之后以同样的状态转移方程迭代，注意第n号房间可以抢，也可以不抢。

class Solution {
    public int rob(int[] nums) {
        int n = nums.length;
        if (n == 1) {
            return nums[0];
        }
        if (n == 2) {
            return Math.max(nums[0], nums[1]);
        }
        int[] dp = new int[n+1];
        // 连起来了，那么 1号房可能抢、不抢，我们需要比较两种情况下的价值
        // 先看1号房间抢
        dp[1] = nums[0];
        // 2号房间，看抢 1 号 还是 2号
        dp[2] = Math.max(nums[0], nums[1]); 
        for (int i = 3; i < n; i++) {
            // 分为抢和不抢
            dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i-1]);
        }
        // 注意因为 1号房间抢了，所以 n号房间不能抢！！
        // 此时 n号房间的价值就只能是 dp[n-1]
        int first = dp[n-1];
        // 再看1号房间不抢
        dp = new int[n+1];
        dp[1] = 0;
        dp[2] = nums[1];
        // 虽然1号房间不抢，但是 n 号房间也可能抢、不抢
        // 一定要注意，1号房间不抢，不代表 n号房间就要抢
        for (int i = 3; i <= n; i++) {
            dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i-1]);
        }
        return Math.max(first, dp[n]);
    }
}

为了方便理解，在书写代码时都使用了dp数组，但其实可以用几个指针表示，这样就可以优化空间消耗。

删除并获得点数（中等）

在这里插入图片描述
讨论某一个数，它有两种状态：删除、不删除，如果被删除，直接获得它对应的点数（这里隐藏了，其实获得的点数=对应的点数 * 该数的个数，因为你删除本身一个数，同样一个数在数组中可能还存在，删除它们获得相同的点数，并且不会对数组造成新的影响），所以可以得出状态转移方程，对某个正整数n而言：
$d p [n] = m a x (d p [n - 2] + c n t [n] * n, d p [n - 1])$

base case：这道题的初始状态怎么设置呢？dp[n]数组代表什么意思？
应该是：“dp[i]表示删除数组nums中的元素i(nums[i])所获得的最大点数为dp[i]。注意，此时你操作的数组元素范围是[0, i]”。
这里其实我们默认是从0开始找最大点数，所以dp[0] = 0，dp[1] = 1 * cnt[1]，dp[2] = max(dp[0] + 2 * cnt[2], dp[1])

很多时候，题做多了容易得出状态转移方程，但是却不知道dp数组是什么意思，这样虽然能够做题，但给面试官的印象并不好！

class Solution {
    public int deleteAndEarn(int[] nums) {
        // 第n号数，有两种情况：删除、不删除（一旦删除了，它有多少个就可以拿多少点数）
        // 一定要注意，删除了那个数，得到的点数是：那个数 * 个数
        // dp[n] = max(dp[n-2] + cnt[n] * n号数的个数, dp[n-1])
        int n = nums.length;
        if (n == 1) {
            return nums[0];
        }
        if (n == 2) {
            if (nums[1] == nums[0] + 1 || nums[1] == nums[0] - 1) {
                return Math.max(nums[0], nums[1]);
            } else if (nums[0] == nums[1]) {
                return 2 * nums[0];
            } else {
                return nums[0] + nums[1];
            }
        }
        int max = -1;
        // 找最大值确定数组大小
        for (int i = 0; i < n; i++) {
            if (nums[i] > max) {
                max = nums[i];
            }
        }
        int[] cnt = new int[max + 1];
        // 统计数组中各数个数
        for (int i = 0; i < n; i++) {
            cnt[nums[i]]++;
        }
        int[] dp = new int[max + 1];
        // dp[i]表示1 <= x <= i 的整数范围内能够构成的最大值
        dp[1] = 1 * cnt[1];
        dp[2] = Math.max(dp[0] + 2 * cnt[2], dp[1]);
        for (int i = 3; i <= max; i++) {
            dp[i] = Math.max(dp[i - 2] + i * cnt[i], dp[i - 1]);
        }
        return dp[max];
    }
}

跳跃游戏（中等）

在这里插入图片描述
初步感知，遍历每一个下标和其元素，将能到达的位置标记为true。

class Solution {
    public boolean canJump(int[] nums) {
        // nums[i]是该位置可以跳跃的最大长度，意思是可以跳、不跳
        // nums[0] = 2 dp[0] = true dp[1] = true dp[2] = true
        int n = nums.length;
        if (nums[0] >= n - 1) {
            return true;
        }
        boolean[] dp = new boolean[n];
        for (int i = 0; i <= nums[0]; i++) {
            dp[i] = true;
        }
        for (int i = 1; i < nums.length; i++) {
            if (dp[i] == true) {
                for (int j = 0; j <= nums[i]; j++) {
                    if ((i + j) < n) {
                        dp[i + j] = true;
                    } else {
                        break;
                    }
                }
            }
        }
        return dp[n - 1];
    }
}

是否可以优化？注意每个下标对应的元素是指能够跳跃的最大位置，意思是说可以跳0-n步，那么我们直接看它当前下标最多能跳多远就可以了，因为小于最大下标的位置都可以跳到。

class Solution {
    public boolean canJump(int[] nums) {
        // nums[i]是该位置可以跳跃的最大长度，意思是可以跳、不跳
        // 关键点：如果从当前位置最远能够到达 k，那么在 k 之前的位置都是可以到达的
        int n = nums.length;
        int dp = 0;
        for (int i = 0; i < n; i++) {
            if (dp < i) {
                // 前面最大值的情况都到不了i下标了
                return false;
            }
            // 只用更新能跳到的最远下标即可，因为小于最远下标的所有下标都能跳到
            dp = Math.max(dp, i + nums[i]);
        }
        return dp >= (n - 1);
    }
}

从上面代码可以看出，其实解题思路更偏向贪心，动态规划也能解，只是速度慢。

跳跃游戏Ⅱ（中等）

在这里插入图片描述
遍历当前下标能够到达的下标，如果跳跃数更小，就更新该下标的跳跃数，dp数组记录到达每个下标所需的最小跳跃数。

class Solution {
    public int jump(int[] nums) {
        int n = nums.length;
        if (n == 1) {
            return 0;
        }
        int[] dp = new int[n];
        Arrays.fill(dp, n);
        dp[0] = 0;
        for (int i = 0; i < n; i++) {
            // 记录下当前下标能跳到的最远位置
            int k = i + nums[i];
            int j = i + 1;
            while (j <= k && j < n) {
                dp[j] = Math.min(dp[j], dp[i] + 1);
                j++;
            }
        }
        return dp[n - 1];
    }
}

最大子数组和（简单）

在这里插入图片描述
对于数组中某一个数，具有两种状态，选它、不选它。选它，那么全局和就加上它，不选它，那么全局和就是它自己，因为子数组必须连续且至少有一个数，dp数组的含义是：第 i 个数结尾的「连续子数组的最大和」（在题目条件下），所以很容易就能写出状态转移方程：
$d p [n] = m a x (d p [n - 1] + n u m s [n], n u m s [n])$
也可以写成：因为如果前一个dp为负数，怎么加都会小于自身的nums，所以直接看前一个dp值即可。
$d p [n] = n u m s [n] + m a x (d p [n - 1], 0)$
注意，因为dp数组的含义是必须以第 i 个数结尾的连续子数组的最大和，所以dp[n]不一定能成为全局最大值，应该时刻比较记录最大值。

写出相应代码如下：

class Solution {
    public int maxSubArray(int[] nums) {
        // 对于某一个数，有两种状态：选它，不选它
        // 如果不选它，前 i 个数能组成的最大和就是它本身（因为必须至少包含一个数
        // 如果选它，全局和 + 当前数
        int n = nums.length;
        int[] dp = new int[n + 1];
        // dp数组代表数组前 i 个数，能够组成的最大和（注意：是连续的子数组且必须包含一个数）
        dp[0] = 0;
        int max = Integer.MIN_VALUE;
        // dp[n] = max(nums[n], dp[n-1] + nums[n])
        for (int i = 1; i <= n; i++) {
            dp[i] = Math.max(nums[i - 1], dp[i - 1] + nums[i - 1]);
            max = Math.max(dp[i], max);
        }
        return max;
    }
}

扩展：由本题的状态转移方程，可以推出最小子数组和的状态转移方程，如下：
$d p [n] = m i n (d p [n - 1] + n u m s [n], n u m s [n])$
也可以写成：
$d p [n] = n u m s [n] + m i n (d p [n - 1], 0)$

※环形子数组最大和（中等）（上一题升级版）

在这里插入图片描述

在这里插入图片描述
如上图所示，产生最大和的子数组无非就两种情况，一种不成环，一种成环。成环的情况用上一题方法直接求解，成环的情况该如何求解？

直接给出结论：成环情况的最大值=数组总和 - 未成环部分的最小子数组和

这里贴出LeetCode上的证明：
地址：https://leetcode-cn.com/problems/maximum-sum-circular-subarray/solution/wo-hua-yi-bian-jiu-kan-dong-de-ti-jie-ni-892u/
在这里插入图片描述
获得两种情况下的最大值后，比较获得更大的一个，即为最终的答案。

这道题和打家劫舍Ⅱ类似，都要分两种情况讨论，以后遇到成环的问题一定要分开讨论。

class Solution {
    public int maxSubarraySumCircular(int[] nums) {
        // 分两种情况：最大和在未成环状态下产生、最大和在成环状态下产生
        // 先算未成环，就和53题一样，正常求解
        int n = nums.length;
        if (n == 1) {
            return nums[0];
        }
        int[] dp = new int[n];
        dp[0] = nums[0];
        int max = nums[0];
        int sum = nums[0];
        for (int i = 1; i < n; i++) {
            // 采用第二种状态转移方程
            dp[i] = nums[i] + Math.max(dp[i - 1], 0);
            max = Math.max(dp[i], max);
            // 统计数组中所有元素的的和
            sum += nums[i];
        }
        // 再统计成环的情况，那么最大和的子数组一定包含第一个元素和最后一个元素（只有这样才能成环）
        // 假设数组范围：nums[0] - nums[n - 1]
        // 那么遍历范围：nums[1] - nums[n - 2
        int min = nums[1];
        for (int i = 1; i < n - 1; i++) {
            dp[i] = nums[i] + Math.min(dp[i - 1], 0);
            min = Math.min(min, dp[i]);
        }
        return Math.max(sum - min, max);
    }
}

※乘积最大子数组（中等）

在这里插入图片描述
先来直观的想法，和53题（最大子数组和）一样，写出状态转移方程：
$d p [n] = m a x (d p [n - 1] * n u m s [n], n u m s [n])$
这个写法是否有问题？ 显然是有问题的，例如：-3,2,-3，上面方程得出的结果是2，但是实际是18，问题在于少考虑了负负得正的情况！ 负负得正的情况是在当前数为负数的情况下才考虑，并且要是前面能获得的最小负数，乘出来的结果才可能大；如果是正数直接考虑前面的最大值即可。

新的状态转移方程：
$m a x a r r [n] = m a x (n u m s [n], m a x a r r [n - 1] * n u m s [n], m i n a r r [n - 1] * n u m s [n])$
$m i n a r r [n] = m i n (n u m s [n], m a x a r r [n - 1] * n u m s [n], m i n i a r r [n - 1] * n u m s [n])$

maxarr[i] 和 minarr[i]，代表以第i个数结尾的最大、最小子数组乘积。

class Solution {
    public int maxProduct(int[] nums) {
        // 53题的改编题
        int n = nums.length;
        int[] max_arr = new int[n];
        int[] min_arr = new int[n];
        max_arr[0] = nums[0];
        min_arr[0] = nums[0];
        // max_arr[i]指以第i个数结尾的子数组的最大乘积
        // min_arr[i]指以第i个数结尾的子数组的最小乘积
        // 考虑数组中某个数nums[i]，需要考虑负数 * 负数 和 正数 * 正数，最大值一定在它们之间产生
        int max = nums[0];
        for (int i = 1; i < n; i++) {
            max_arr[i] = Math.max(nums[i], Math.max(max_arr[i - 1] * nums[i], min_arr[i - 1] * nums[i]));
            min_arr[i] = Math.min(nums[i], Math.min(max_arr[i - 1] * nums[i], min_arr[i - 1] * nums[i]));
            max = Math.max(max_arr[i], max);
        }
        return max;
    }
}

※乘积为正数的最长子数组长度（中等+）

在这里插入图片描述
第一次遇到没有想出来，但知道应该是要分成正负情况讨论的（和上一题一样），下面开始讨论：

题解地址： https://leetcode-cn.com/problems/maximum-length-of-subarray-with-positive-product/solution/cheng-ji-wei-zheng-shu-de-zui-chang-zi-shu-zu-ch-3/

对上述题解的说明：
1、nums[i] > 0 时，pos数组的计算：pos[i] = pos[i - 1] + 1，如果pos[i - 1] = 0，说明以第 i - 1个数结尾的连续数组的乘积非正（就是可能为0、负数），但nums[i]本身是正数，所以得+1；如果pos[i - 1] != 0，说明以第 i - 1个数结尾的连续数组的乘积为正，那就是“正大光明”地+1即可。综上，不管pos[i - 1]的大小，都可以写成pos[i] = pos[i - 1] + 1。

2、nums[i] > 0 时，neg数组的计算：为什么不能直接 neg[i] = neg[i - 1] + 1？，因为如果neg[i - 1] = 0，说明以第 i - 1个数结尾的连续数组的乘积非负（可能为正、可能为0）而nums[i]本身又是大于0的数，不可能是+1，应该就是0。如果neg[i - 1] > 0，说明以第 i - 1个数结尾的连续数组的乘积为负，乘上正数还为负，所以neg[i] = neg[i - 1] + 1。综上，需要对neg[i - 1]的大小进行判断，写出相应的状态转移方程。

3、对nums[i] < 0的讨论同理，neg[i] = pos[i - 1] + 1无论pos[i - 1]的大小都可以直接使用，因为nums[i]本身是小于0的。pos[i]的更新要取决于neg[i - 1]，如果neg[i - 1] > 0，说明以第 i - 1个数结尾的连续数组的乘积为负，负负得正，所以pos[i] = neg[i - 1] + 1；如果neg[i - 1] = 0，说明xxxx乘积为非负（可正、可0），加之nums[i]本身是负数，所以neg[i] = 0。

4、最后还需要讨论nums[i] = 0的情况，一旦为0，neg[i] pos[i] 都为0，0乘任何数=0。

neg、pos数组的含义：以第 i 个数结尾的子数组乘积为负、正的最大长度。

class Solution {
    public int getMaxLen(int[] nums) {
        int n = nums.length;
        int[] pos = new int[n];
        int[] neg = new int[n];
        if (nums[0] > 0) {
            pos[0] = 1;
        }
        if (nums[0] < 0) {
            neg[0] = 1;
        }
        // 第一个数为0的话，都为0，默认数组=0
        int max = pos[0];
        for (int i = 1; i < n; i++) {
            if (nums[i] > 0) {
                pos[i] = pos[i - 1] + 1;
                if (neg[i - 1] > 0) {
                    neg[i] = neg[i - 1] + 1;
                }else {
                    neg[i] = 0;
                }
            } else if (nums[i] < 0) {
                // pos[i - 1] = 0 、> 0都是成立的，别忘了这是乘积
                neg[i] = pos[i - 1] + 1;
                if (neg[i - 1] > 0) {
                    // 负负得正
                    pos[i] = neg[i - 1] + 1;
                } else {
                    // 非负（可正、可0）
                    pos[i] = 0;
                }
            } else {
                // 当前元素 = 0
                pos[i] = 0;
                neg[i] = 0;
            }
            // 找的是乘积为正的最长子数组长度
            max = Math.max(max, pos[i]);
        }
        return max;
    }
}

遇到乘积问题一定要讨论正负情况！

最佳观光组合（中等）（脑筋急转弯）

在这里插入图片描述
把values[i] + values[j] + i - j，拆分为values[i] + i，values[j] - j，对于第 j 个景点，values[j] - j 是固定的，只需找到values[i] + i 的最大值。

class Solution {
    public int maxScoreSightseeingPair(int[] values) {
        // 两个景点：i、j组合得分 = values[i] + values[j] - (j - i)
        // 对于经典 j，它的values[j] - j 是固定的，只需找到max(values[i] + i)即可
        // max(values[i] + i)可以在遍历的过程中直接得到
        int mx = values[0] + 0;
        int ans = 0;
        for (int i = 1; i < values.length; i++) {
            ans = Math.max(ans, values[i] - i + mx);
            mx = Math.max(mx, values[i] + i);
        }
        return ans;
    }
}

持续更新ing…

@u@

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
【算法练习】LeetCode-动态规划学习计划

动态规划解题模板： // 初始化 base case dp[0][0][...] = base; // 进行状态转移（遍历所有状态） for 状态1 in 状态1的所有取值: for 状态2 in 状态2的所有取值: for ... dp[状态1][状态2][...] = 求最值(选择1, 选择2, ...)爬楼梯（简单）class Solu
复制链接

扫一扫