动态规划刷题(持续更新.....)

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

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

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶
示例 2：

输入： 3
输出： 3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

首先拿到这道题为什么要使用动态规划？

根据上文，在推导后面阶段状态的时候，我们只关心前面阶段的状态值，不关心这个状态是怎么一步步推导出来的。同样的，这道题中，我站在第n个台阶上，怎么上来的？可以是在n-1阶上迈一步，也可以是在n-2阶上迈两步这两种方法。但是是如何到达n-1和n-2阶的呢？不关心。

class Solution {
    public static int climbStairs(int n) {
        // 定义出口
        if( n==1 )  return 1;
        if( n==2 )  return 2;
        // 我们从1开始 ，0不要了
        int [] dp = new int[n+1];
        dp[1]=1;
        dp[2]=2;
        
        for (int i = 3; i <= n; i++) {
            dp[i]=dp[i-1]+dp[i-2];
        }

        return dp[n];
    }
}

2. LC 121. 买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择某一天买入这只股票，并选择在未来的某一个不同的日子卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：

输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

上来的想法就是暴力解，双循环，结果超时了。

然后最自然的想法就是左边取最小，右边取最大。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int low = INT_MAX;
        int result = 0;
        for (int i = 0; i < prices.size(); i++) {
            low = min(low, prices[i]);  // 取最左最小价格
            result = max(result, prices[i] - low); // 直接取最大区间利润
        }
        return result;
    }
};

然后题目说求最值，那么想到动态规划。

我觉得这道题比较难的是dp数组的含义即状态如何定义。至于是怎么想到的，大家可以去LeetCode上看看大家的思路，我自己是想不出。

1.定义状态：

这里dp[i][0] 表示第i天持有股票的情况下，拥有的现金。(如果第i天买了股票，则dp[i][0] = 0-price[i])。

dp[i][1]表示第i天不持有股票的情况下，拥有的现金。

2.状态转移

先说dp[i][0]，第i天持有股票的情况，可能是第i天前某一天买入的，也可能是第i天买入的。

dp[i][0] = dp[i-1][0](第一种情况第i-1天一定是买入的状态) 和 0-price[i] 中取较大的(因为要花费最小，才能收益最大)。

再说dp[i][1]，第i天不持有股票，同样两种情况。可能是第i天前就不持有股票(有可能是卖了也有可能压根没买过，不关心)，也可能是第i天卖了。

dp[i][1] = dp[i-1][1] 和dp[i-1][0] + price[i] （前一天还持有，第i天卖出）中的较大值（因为要卖出点最大，才能收益最大）。

public static int maxProfit(int[] prices) {
        int [][] dp = new int[prices.length][2];
        // 初始化 第0天持有就是第0天就买了。
        dp[0][0] = prices[0] * -1;
        dp[0][1] = 0;
        for (int i = 1; i < prices.length; i++) {
            dp[i][0] = Math.max(dp[i-1][0],prices[i] * -1);
            dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0] + prices[i]);
        }
        return dp[dp.length-1][1];
    }

不过这速度堪忧啊。。。

先把题目能做出来，之后再考虑优化。

3. LC 53. 最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

求最大和，想动态规划。

1. 定义状态

dp[i]代表以i为最后一个元素的连续子数组的最大和。

2.状态转移

dp[i]这个状态可以有以下两种方式转移来：i. 第i-1个元素加上第i个元素得来的。ii.i-1之前的和都太小了，可能是负数或者前面加起来还没i大，那我i就自己走自己的了。

所以dp[i] = Math.max(dp[i-1] + nums[i], nums[i]);

3.返回值

遍历dp数组，找最大的返回就可以啦。

public static int maxSubArray(int[] nums) {
        // dp[i] : 表示以nums[i]为结尾的最大连续子数组的和。
        if (nums.length == 0) return 0;
        if (nums.length == 1) return nums[0];

        int [] dp = new int[nums.length];
        dp[0] = nums[0];
        for (int i = 1; i < nums.length; i++) {
            dp[i] = Math.max(nums[i],dp[i-1] + nums[i]);
        }
        int res = Integer.MIN_VALUE;
        for (int i = 0; i < dp.length; i++) {
            if (dp[i] > res)
                res = dp[i];
        }
        return res;
    }

4. LC 152. 乘积最大子数组

给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。

示例 1:

输入: [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。

和第3题有点像嗷，但是乘积有个很不同的点就是，如果第i天之前的乘积为负数，如果第i天也是负数，那么乘积可能就会变成最大值。

所以在第3题的基础上还要再维护一个最小乘积数组。

1.状态定义

和第3题差不多，dpMax[i] 代表以i为最后一个元素的子数组最大乘积。dpMin[i]代表以i为最后一个元素为最后一个元素的子数组最小乘积。

2.状态转移

dpMax[i] 可能是有三种情况转移来的： dp[i-1] * nums[i], nums[i], dpMin[i-1] *nums[i]

dpMin[i] 同理。

//dpMax[i] = Math.max(dpMax[i-1]*nums[i],nums[i],dpMin[i-1]*nums[i])
//dpMin[i] = Math.min(dpMin[i-1]*nums[i],nums[i],dpMax[i-1]*nums[i])

3. 结果

遍历dpMax，返回最大的。

public static int maxProduct(int[] nums) {
        // 维护一个最大乘积dp 和 一个最小乘积dp
        int [] dpMax = new int[nums.length];
        int [] dpMin = new int[nums.length];

        //dpMax[i]代表以i为最后一个元素的子数组乘积。
        //dpMax[i] = Math.max(dpMax[i-1]*nums[i],nums[i],dpMin[i-1]*nums[i])
        //dpMin[i] = Math.min(dpMin[i-1]*nums[i],nums[i],dpMax[i-1]*nums[i])
        dpMax[0] = dpMin[0] = nums[0];

        for (int i = 1; i < nums.length; i++) {
            dpMax[i] = Math.max(dpMax[i-1]*nums[i],Math.max(nums[i],dpMin[i-1]*nums[i]));
            dpMin[i] = Math.min(dpMin[i-1]*nums[i],Math.min(nums[i],dpMax[i-1]*nums[i]));
        }
        int res = Integer.MIN_VALUE;
        for (int i = 0; i < dpMax.length; i++) {
            if (res < dpMax[i])
                res = dpMax[i];
        }
        return res;
    }

5. LC 718. 最长重复子数组

给两个整数数组 A 和 B ，返回两个数组中公共的、长度最长的子数组的长度。

示例：

输入：
A: [1,2,3,2,1]
B: [3,2,1,4,7]
输出：3
解释：
长度最长的公共子数组是 [3, 2, 1] 。

dp[i][j] 代表以A[i-1] B[j-1] 为最后一个元素的最长子数组的长度。

dp[i][j] 的取值取决于当前数字，也就是A[i-1] B[j-1] 是否相等。如果二者相等，那么dp[i][j] = dp[i-1][j-1] +1;否则dp[i][j] = 0;

public int findLength(int[] A, int[] B) {
        // dp[i][j]
        int max = 0;
        int [][] dp = new int[A.length+1][B.length+1];
        for (int i = 1; i <= A.length; i++) {
            for (int j = 1; j <= B.length; j++) {
                if (A[i-1] == B[j-1])
                    dp[i][j] = dp[i-1][j-1] + 1;
                else dp[i][j] = 0;
                max = Math.max(max, dp[i][j]);
            }
        }
        return max;
    }