动态规划之子序列类型问题

300. 最长递增子序列

class Solution {
    
    
    public int lengthOfLIS(int[] nums) {
    
    
        int[] dp = new int[nums.length]; // 以下标 i 为结尾的最长严格递增子序列的长度是 dp[i]
        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);
                }
            }
        }
        int res = 0;
        for(int i = 0; i < dp.length; i++){
    
    
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

354. 俄罗斯套娃信封问题

class Solution {
    
    
    public int maxEnvelopes(int[][] envelopes) {
    
    
        Arrays.sort(envelopes, new Comparator<int[]>(){
    
    
            public int compare(int[] a, int[] b){
    
    
                if(a[0] == b[0]){
    
    
                    return b[1] - a[1];
                }
                return a[0] - b[0];
            }
        });
        int[] dp = new int[envelopes.length]; // 以下标 i 为结尾时最多可以有 dp[i] 个信封
        Arrays.fill(dp, 1);
        for(int i = 1; i < dp.length; i++){
    
    
            for(int j = 0; j < i; j++){
    
    
                if(envelopes[i][0] > envelopes[j][0] && envelopes[i][1] > envelopes[j][1]){
    
    
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
        } 
        int res = 0;
        for(int i = 0; i < dp.length; i++){
    
    
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

53. 最大子序和

class Solution {
    
    
    public int maxSubArray(int[] nums) {
    
    
        int[] dp = new int[nums.length]; // 以下标 i 为结尾的最大子数组和为 dp[i]
        dp[0] = nums[0];
        for(int i = 1; i < dp.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++){
    
    
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

72. 编辑距离

class Solution {
    
    
    public int minDistance(String word1, String word2) {
    
    
        int m = word1.length(), n = word2.length();
        int[][] dp = new int[m + 1][n + 1]; // word1 的前 i 个字符变成 word2 的前 j 个字符所需要的最小操作数是 dp[i][j]
        for(int j = 0; j <= n; j++){
    
    
            dp[0][j] = j;
        }
        for(int i = 0; i <= m; i++){
    
    
            dp[i][0] = i;
        }
        for(int i = 1; i <= m; i++){
    
    
            for(int j = 1; j <= n; j++){
    
    
                if(word1.charAt(i - 1) == word2.charAt(j - 1)){
    
    
                    dp[i][j] = dp[i - 1][j - 1];
                }else{
    
    
                    // 增，删，改
                    dp[i][j] = getMin(dp[i][j - 1] + 1, dp[i - 1][j] + 1, dp[i - 1][j - 1] + 1);
                }
                
            }
        }
        return dp[m][n];
    }
    public int getMin(int a, int b, int c){
    
    
        int min = Math.min(a, b);
        return Math.min(min, c);
    }
}

1143. 最长公共子序列

class Solution {
    
    
    public int longestCommonSubsequence(String text1, String text2) {
    
    
        int m = text1.length();
        int n = text2.length();
        int[][] dp = new int[m + 1][n + 1]; // text1 的前 i 个字符和 text2 的前 j 个字符的公共子序列长度为 dp[i][j]
        for(int i = 1; i <= m; i++){
    
    
            for(int j = 1; j <= n; j++){
    
    
                if(text1.charAt(i - 1) == text2.charAt(j - 1)){
    
    
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }else{
    
    
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[m][n];
    }
}

583. 两个字符串的删除操作

class Solution {
    
    
    public int minDistance(String word1, String word2) {
    
    
        int m = word1.length();
        int n = word2.length();
        int[][] dp = new int[m + 1][n + 1]; // 使 word1 的前 i 个字符和 word2 的前 j 个字符相等所需的最小步数
        for(int i = 0; i <= m; i++){
    
    
            dp[i][0] = i;
        }
        for(int j = 0; j <= n; j++){
    
    
            dp[0][j] = j;
        }
        for(int i = 1; i <= m; i++){
    
    
            for(int j = 1; j <= n; j++){
    
    
                if(word1.charAt(i - 1) == word2.charAt(j - 1)){
    
    
                    dp[i][j] = dp[i - 1][j - 1];
                }else{
    
    
                    dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + 1;
                    // dp[i][j] = Math.min(dp[i - 1][j - 1] + 2, Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1));
                }
            }
        }
        return dp[m][n];
    }
}

• 删除后的结果其实就是两个字符串的最长公共子序列，因此本题可以转换为：求两个字符串的最长公共子序列。

712. 两个字符串的最小ASCII删除和

class Solution {
    
    
    public int minimumDeleteSum(String s1, String s2) {
    
    
        int m = s1.length();
        int n = s2.length();
        int[][] dp = new int[m + 1][n + 1]; // 使 s1 的前 i 个字符和 s2 的前 j 个字符相等所需删除字符的 ASCII 值的最小和为 dp[i][j]
        for(int i = 1; i <= m; i++){
    
    
            dp[i][0] = dp[i - 1][0] + s1.charAt(i - 1);
        }
        for(int j = 1; j <= n; j++){
    
    
            dp[0][j] = dp[0][j - 1] + s2.charAt(j - 1);
        }
        for(int i = 1; i <= m; i++){
    
    
            for(int j = 1; j <= n; j++){
    
    
                if(s1.charAt(i - 1) == s2.charAt(j - 1)){
    
    
                    dp[i][j] = dp[i - 1][j - 1];
                }else{
    
    
                    dp[i][j] = Math.min(dp[i - 1][j - 1] + s1.charAt(i - 1) + s2.charAt(j - 1), Math.min(dp[i - 1][j] + s1.charAt(i - 1), dp[i][j - 1] + s2.charAt(j - 1)));
                }
            }
        }
        return dp[m][n];
    }
}