最长递增子序列和最长公共子序列以及最长回文子序列详解

子序列问题求解

这类子序列问题都可以使用动态规划的思想来解决其中最长递增子序列使用一维动态数组
最长公共子序列和最长回文子序列使用二维动态数组

最长递增子序列
使用一维动态数组

class Solution {
    public int lengthOfLIS(int[] nums) {
        // 定义dp 数组 dp[i]表示以nums[i]结尾最长上升子序列
        int []dp = new int[nums.length];
        // baseCase nums[i]为最小的情况下  最长上升子序列为1
        for(int i = 0;i<dp.length;i++){
            dp[i] = 1;
        }
        //resMax用来存放最大值 
        int resMax = 1;
        // 遍历数组中的每个元素 并且与当前元素前面的元素做比较 找到以每个元素结尾的最长递增长度
        for(int i = 1;i<dp.length;i++){
            //找到以dp[i]结尾的最长递增长度
            for(int j = i-1;j>=0;j--){
                if(nums[i]>nums[j]){
                    dp[i] = Math.max(dp[i],dp[j]+1);
                }
            }
            //更新数组中目前最长递增长度
            resMax = resMax>dp[i]?resMax:dp[i];
        }
        return resMax;
    }
}

最长公共子序列
使用二维动态数组

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        // 定义dp数组  dp[i][j]的含义:s1[1..i]和s2[1..j]，它们的 最长公共子序列长度是dp[i][j]
        int [][]dp = new int[text1.length()+1][text2.length()+1];

        // 确定baseCase 当两个字符串分别为空串时 最长公共子序列也为空 长度为0


        for(int i = 1;i<dp.length;i++){
            for(int j = 1;j<dp[i].length;j++){
                //如果第i,j两个字符相等 则最长公共子序列就是dp[i-1][j-1]+1
                if(text1.charAt(i-1)==text2.charAt(j-1)){
                    dp[i][j] = dp[i-1][j-1]+1;
                }else{
                    //如果不相等则是dp[i-1][j]和dp[i][j-1]中取较大值
                    dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1]);
                }
            }
        }
        return dp[text1.length()][text2.length()];
    }
}

最长回文子序列
最长回文子序列也使用的二维的动态数组

class Solution {
    public int longestPalindromeSubseq(String s) {
        // 定有dp数组 dp[i][j] 含义为 是s[i....j]这个子串 此时最长的回文子序列
        int [][] dp = new int [s.length()][s.length()];

        // 确定baseCase 当i==j时表示一个字符  最长的回文子序列就是1
        // 当i>j时字符串都不存在 所有最长回文子序列长度就是0
        for(int i = 0;i<dp.length;i++){
            dp[i][i] = 1;
        }

        // dp[i][j]需要知道dp[i+1][j-1],dp[i+1][j],dp[i][j-1] 必须反向遍历 或者斜向遍历
        // 进行反向遍历
        for(int i = s.length()-2;i>=0;i--){
            for(int j = i+1;j<s.length();j++){
                //如果相等则回文串长度在dp[i+1][j-1]上加2
                if(s.charAt(i)==s.charAt(j)){
                    dp[i][j] = dp[i+1][j-1]+2;
                }else{
                    //如果不相等则取i,j区间内子串i+1,j和i,j-1的最大值
                    dp[i][j] = Math.max(dp[i+1][j],dp[i][j-1]);
                }
            }
        }
        return dp[0][s.length()-1];
    }
}