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

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];
    }
}

标签：nums,int,res,length,之子,Math,序列,动态,dp
来源： https://blog.csdn.net/weixin_46497503/article/details/121141493