LeetCode分类习题-动态规划

动态规划

可以利用动态规划解决的问题有这样一种特点：总问题可分解为子问题，而每一步子问题都依赖于前一步或前几步的结果。动态规划的求解速度相对于朴素解法更快，因为子问题的结果已经被记录，后面需要的时候直接调用即可。

动态规划的步骤：

1. 确定状态代表什么（dp[i]或dp[i] [j]都代表啥）;
2. 状态如何转移的（dp[i] 和dp[i - 1] 或dp[i - k]之间的关系），一开始可以先枚举尝试，如果特别麻烦建议回到步骤1重新定义状态；
3. 确定边界条件（dp[0]或dp[0] [0]都是啥）；
4. 确定输出是什么？是dp中的某个元素还是dp的最大值、最小值等；
5. 时、空复杂度能否优化？

1. 最长上升子序列

状态：dp[i]表示以该元素结尾的最长上升子序列长度

转移：遍历0~i上的每个元素（索引为j），如果nums[i] > nums[j]，此时dp[i] 更新为max(dp[j] + 1, dp[i])，每一轮遍历dp[i]都不断被更新，所以要用max(dp[j] + 1, dp[i])。

需要遍历两次输入数组，O(n^2)

class Solution {
    
    public int lengthOfLIS(int[] nums) {
        if (nums.length == 0) return 0;
        int[] dp = new int[nums.length];
        // base case
        Arrays.fill(dp, 1);

        for (int i = 1;i < dp.length;i++){
            for (int j = 0;j < i;j++){
                if (nums[i] > nums[j]){
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
        }
        return getMax(dp);
    }
    
    private static int getMax(int [] arr){
        int max = arr[0];
        for (int i = 1;i < arr.length;i++){
            if (max < arr[i]) max = arr[i];
        }
        return max;
    }
}

2. 最长连续递增序列

状态：dp[i]表示以当前元素结尾的最长连续递增序列长度

转移：如果nums[i] > nums[i - 1]，dp[i] = dp[i - 1];否则dp[i] 维持初始值，即1，因为要求连续所以只需要和上一个元素对比即可，遍历数组一次即可，O(n)。

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        if (nums.length == 0) return 0;

        int[] dp = new int[nums.length];
        // base case
        Arrays.fill(dp, 1);

        for (int i = 1;i < dp.length;i++){
            if (nums[i] > nums[i-1]){
                // 状态转移
                dp[i] = dp[i-1] + 1;
            }
        }
        return getMax(dp);

    }

    private static int getMax(int[] arr){
        int max = arr[0];
        for (int i = 1;i < arr.length;i++){
            if (max < arr[i]){
                max = arr[i];
            }
        }
        return max;
    }
}

3. 最长回文子串

状态：回文涉及到首尾两个元素，下意识维护一个二维dp数组。dp[i] [j]表示已i位置元素开头，j位置元素结尾的子串是否为回文。

转移：如果s[i] == s[j]，dp[i] [j] = dp[i+1] [j-1]；否则仍为false

class Solution {
    public String longestPalindrome(String s) {
        if (s.length() == 0) return "";

        boolean[][] dp = new boolean[s.length()][s.length()];
        String ans = "";

        // 回文子串不断增长（len为子串长度-1）
        for (int len = 0;len < s.length();len++){
            // 遍历子串起始位置
            for (int i = 0;i < s.length() && (i + len) < s.length();i++){
                int j = i + len;
                // 长度为1时
                if (len == 0) {
                    dp[i][j] = true;
                // 长度为2时    
                }else if (len == 1) {
                    dp[i][j] = s.charAt(i) == s.charAt(j);
                }else{
                    dp[i][j] = dp[i+1][j-1] && s.charAt(i) == s.charAt(j);
                }
                // 每轮循环结束后判定是否要更新ans，len+1大于ans长度时就要更新，因为具体子串的起始位置是在内层循环的，所以在				内层循环中更新，同一len下反复更新也无所谓
                if (dp[i][j] && len + 1 > ans.length()){
                ans = s.substring(i, j+1);
                }
            }
            
        }
        return ans;
    }
}

4. 最长回文子序列

状态：dp[i] [j]表示以i位置开始，j位置结束的区间内最长回文子序列长度

转移：如果s[i] == s[j]，dp[i] [j] = dp[i+1] [j-1]；否则i，j区间内最长子序列必然不包括i或j位置上的一个。

状态填充：一般来说一维dp直接顺序遍历，而二维dp的填充还要考虑以怎样的顺序遍历。根据状态的定义，dp[i] [j]可能需要dp[i+1] [j]或dp[i] [j-1]，所以i逆序遍历，j正序遍历。

class Solution {
    public int longestPalindromeSubseq(String s) {
        int n = s.length();
        if (n < 2) return n;

        int[][] dp = new int[n][n];
        for (int i = n - 1;i >= 0;i--){
            dp[i][i] = 1;
            for (int j = i + 1;j < n;j++){
                if (s.charAt(i) == s.charAt(j)){
                    dp[i][j] = dp[i+1][j-1] + 2;
                }else{
                    dp[i][j] = Math.max(dp[i][j-1], dp[i+1][j]);
                }
            }
        }
        return dp[0][n-1];
    }
}

5. 编辑距离

状态：word1与word2之间的距离可以基于二者子字符串的距离，dp[i] [j]表示word1前i个字符串变成word2前j个字符串所需要操作数。

转移：如果word1[i] == word2[j]，那么dp[i] [j] = dp[i-1] [j-1]；否则去其左、左上、上三个元素中最小值并加上1即可。

状态确定：根据图示，顺序遍历即可。

class Solution {
    public int minDistance(String word1, String word2) {
        int n1 = word1.length();
        int n2 = word2.length();
        // dp数组每一维度增加1，表示字符串变为空所需要操作数
        int[][] dp = new int[n1 + 1][n2 + 1];
        // 边界条件初始化
        for (int i = 0;i < n1 + 1;i++){
            dp[i][0] = i;
        }
        for (int i = 0;i < n2 + 1;i++){
            dp[0][i] = i;
        }

        for (int i = 1;i < n1 + 1;i++){
            for (int j = 1;j < n2 + 1;j++){
                dp[i][j] = 
                word1.charAt(i-1) == word2.charAt(j-1)? 
                dp[i-1][j-1]: 
                minBetweenThree(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1;
            }
        }
        return dp[n1][n2];

    }

    private static int minBetweenThree(int a, int b, int c){
        if (a > b){
            return Math.min(b, c);
        }else{
            return Math.min(a, c);
        }
    }
}

6. 打家劫舍

状态：介绍下心路历程，因为不是每家都会被偷，所以dp[i]不宜表示偷到第i家时的收入；dp[i]也不宜表示偷了第i家的最大收入，因为这样定义的dp[i]需要dp[i-k]…dp[i+k]，不太好循环遍历；因此dp[i]定义为来到第i家时（可以偷或不偷）所能达到的最大收入，从这个角度来看，顺序遍历的时候有点贪心的意思，不难看出本题恰好贪心是最优的。

转移：相邻两家不能偷，dp[i-2] + nums[i] 和 dp[i-1]选大的，前者意味着i-1时不偷，后者意味着i时不偷。

状态确定：顺序遍历即可。

class Solution {
    public int rob(int[] nums) {
        int n = nums.length;
        if (n == 0) return 0;
        if (n == 1) return nums[0];

        int[] dp = new int[n];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);
        for (int i = 2;i < n;i++){
            dp[i] = Math.max(dp[i-2] + nums[i], dp[i-1]);
        }

        return dp[n-1];
    }
}

7. 打家劫舍（二）

核心部分与上一题一样，但是首尾两家不能同时偷，所以取不偷第一家和不偷最后一家的较大者。

class Solution {
    public int rob(int[] nums) {
        int n = nums.length;
        if (n == 0) return 0;
        if (n == 1) return nums[0];

        return Math.max(rob1(Arrays.copyOfRange(nums, 0, n-1)), rob1(Arrays.copyOfRange(nums, 1, n)));
    }

    private static int rob1(int[] nums){
        int n = nums.length;
        if (n == 0) return 0;
        if (n == 1) return nums[0];
        int[] dp = new int[n];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);

        for (int i = 2;i < n;i++){
            dp[i] = Math.max(dp[i-2] + nums[i], dp[i-1]);
        }
        return dp[n-1];
    }
}