备战秋招DAY5-今日力扣-动态规划

在做动态规划问题之前，首先要明确什么类型的题目是要用到动态规划思想。常见的题目类型有爬楼梯、路径、背包问题、打家劫舍、股票问题、子序列问题等。我个人认为呢，如果某一问题能够分解成多个重叠的子问题，且问题中的每一个状态都是与之前的状态有关联的，就可以用动态规划的思想。

卡哥总结过动态规划的模板，我觉得是非常好的思考方式：

1. 确定dp数组（dp table）以及下标的含义
2. 确定递推公式
3. dp数组如何初始化
4. 确定遍历顺序
5. 举例推导dp数组

每次做题的时候，能够把这五件事理清楚，我觉得就够了！

1. 爬楼梯（难度等级：简单）

我们按照上面的思路来思考这个问题

dp[i]： 爬到第i层楼梯，有dp[i]种方法。

从dp[i]的定义可以看出，dp[i] 可以有两个方向推出来。首先是dp[i - 1]，上i-1层楼梯，有dp[i - 1]种方法，那么再一步跳一个台阶不就是dp[i]了么。还有就是dp[i - 2]，上i-2层楼梯，有dp[i - 2]种方法，那么再一步跳两个台阶不就是dp[i]了么。所以dp[i] = dp[i - 1] + dp[i - 2] 。

初始化dp[1] = 1，dp[2] = 2。

遍历顺序一定是从前向后遍历的

至此，我们就可以开始写代码啦~

class Solution {
    public int climbStairs(int n) {
        if(n==1) return 1;
        int a = 1;
        int b = 2;
        for(int i=2; i<n; i++){
            int c = a + b;
            a = b;
            b = c;
        }
        return b;
    }
}

2. 杨辉三角（难度等级：简单）

这道题的dp[i]就是每层第i个位置处的值，dp[i] = dp_last[i-1]+dp_last[i]，dp_last即上一层的数组。所以我们发现，是需要维护每一层数组的值的。同时，我们也可以观察到每一层的第一个元素和最后一个元素的值都为1。

class Solution {
    public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> res = new ArrayList<>();

        for(int i = 0; i < numRows; i++){
            List<Integer> temp = new ArrayList<>();
            for (int j = 0; j <= i; ++j) {
                if (j == 0 || j == i) {
                    temp.add(1);
                } else {
                    temp.add(res.get(i - 1).get(j - 1) + res.get(i - 1).get(j));
                }
            }
            res.add(temp);
        }
        return res;
    }
}

3.打家劫舍（难度等级：中等）

这道题重点是要get到动态规划数组的元素含义，以及递推公式。dp[i]应表示，打劫到第i家时，小偷能盗窃的最多钱数。而递推公式我们可以这样考虑，对于第i家，其实我们只有偷或者不偷两种状态。如果偷的话，代表上一家我们偷的是dp[i-2]，所以当前dp[i] = dp[i-2] + nums[i]。如果不偷的话，当前状态由dp[i-1]决定（注意是决定！而不是当前的钱数）

class Solution {
    public int rob(int[] nums) {
        if(nums.length == 1) return nums[0];
        int[] money = new int[nums.length];
        money[0] = nums[0];
        money[1] = Math.max(nums[0], nums[1]);
        for(int i=2; i<nums.length; i++){
            money[i] = Math.max(money[i-2]+nums[i], money[i-1]);
        }
        return money[nums.length-1];
    }
}

4.完全平方数（难度等级：中等）

按照动规的思路，我们首先要确定动规数组和递归公式dp[j]：和为j的完全平方数的最少数量为dp[j]。dp[j] 可以由dp[j - i * i]推出， dp[j - i * i] + 1 便可以凑成dp[j]。此时我们要选择最小的dp[j]，所以递推公式：dp[j] = min(dp[j - i * i] + 1, dp[j])。需要注意的是，因为是要取最小值min，所以dp[j]初始化时应该赋大的值，这里我赋的是j，即j个1*1=j，是最坏情况。

class Solution {
    public int numSquares(int n) {
        int[] dp = new int[n+1]; //和为n的完全平方数的最少数量
        dp[0] = 0; 
        for(int i=1; i<=n; i++){
            dp[i] = i;
            for(int j=1; j*j<=i; j++){
                dp[i] = Math.min(dp[i], dp[i-j*j]+1);
            }
        }
        return dp[n];
    }
}

5.零钱兑换（难度等级：中等）

这道题思路上和上一道题很像，不同之处在于零钱兑换不一定能成功，即结果可能返回-1。dp[j]：和为j的零钱的最少数量。dp[j] 可以由dp[j -coins[i]]推出， dp[j -coins[i]] + 1 便可以凑成dp[j]。此时我们要选择最小的dp[j]，所以递推公式：dp[j] = min(dp[j - coins[i]] + 1, dp[j])。一直到这里，都跟上一题真的很像！！！

不过不一样的点马上就来咯~因为最后可能会凑不够零钱，那么这种情况我们如何确定呢？这里可以将dp[j]都初始化为amount+1（因为最坏情况下amount可以兑换amount+1个一块钱），这样在最后返回的时候判断一下和amount的大小即可。

class Solution {
    public int coinChange(int[] coins, int amount) {
        int[] dp = new int[amount+1];
        dp[0] = 0;
        for(int i=1; i<=amount; i++){
            dp[i] = amount+1;
            for(int j=0; j<coins.length ;j++){
                if(i >= coins[j]){
                    dp[i] = Math.min(dp[i-coins[j]]+1, dp[i]);
                }
            }
        }
        return dp[amount] > amount ? -1:dp[amount];
    }
}

6.单词拆分（难度等级：中等）

老样子，先跟着动规的思路理清数组和递推公式。dp[i]表示String的前i个元素是否可被字典拆分。下一步考虑dp[i]的值由什么决定呢？dp[i]应该等于前j-1个能够被拆分的子串 && 从第j位到第i-1位能否被拆分。

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        Set<String> wordDictSet = new HashSet<>(wordDict); //转换为set以便于后序判断子串是否存在
        boolean[] dp = new boolean[s.length()+1]; //到s的第i位的字符串是否可拆分
        dp[0] = true;
        for(int i=1; i<=s.length(); i++){
            for(int j=0; j<i; j++){
                if(dp[j] && wordDictSet.contains(s.substring(j,i))){
                    dp[i] = true;
                    break;
                }
            }
        }
        return dp[s.length()];
    }
}

7.最长递增子序列（难度等级：中等）

定义数组dp[i]为以元素i为结尾（包括元素i）的子数组的最长递增子序列值，那么递推公式就是：当num[i] > nums[j]时，dp[i] = max(dp[i]+1, dp[j])。但这里需要注意的是，整个数组的最长递增子序列并不是以元素i为结尾的值（因为子序列不一定要包含最后一个元素呀），所以我们还需要一个变量来维护最大值~

class Solution {
    public int lengthOfLIS(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n];
        Arrays.fill(dp, 1);
        int ans = 1;
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            ans = Math.max(ans, dp[i]);
        }
        return ans;

    }

8.乘积最大子数组（难度等级：中等）

这道题关键就在于数组中有负数存在，看到一篇很好理解的思路分析：

令imax为当前最大值，则当前最大值为 imax = max(imax * nums[i], nums[i])
由于存在负数，那么会导致最大的变最小的，最小的变最大的。因此还需要维护当前最小值imin，imin = min(imin * nums[i], nums[i])
当负数出现时则imax与imin进行交换再进行下一步计算

因为当前状态的最大值和最小值只和之前一个元素的相关值有关系，所以这里不需要再维护一个动态数组了，减少空间开销。

class Solution {
    public int maxProduct(int[] nums) {
        int max = Integer.MIN_VALUE, imax = 1, imin = 1;
        for(int i=0; i<nums.length; i++){
            if(nums[i] < 0){ 
              int tmp = imax;
              imax = imin;
              imin = tmp;
            }
            imax = Math.max(imax*nums[i], nums[i]);
            imin = Math.min(imin*nums[i], nums[i]);
            
            max = Math.max(max, imax);
        }
        return max;
    }
}

9.分割等和子集（难度等级：中等）