DP子序列系列和子串问题

最长公共子序列

 

package LeetCode.DP;

public class OfferII095 {
    public int longestCommonSubsequence(String text1, String text2) {
            int n=text1.length();
            int m=text2.length();
            return helper(text1,0,text2,0);
    }

    private int  helper(String text1, int n, String text2, int m) {
        if(n==text1.length()||m==text2.length()){
            return 0;
        }
        if(text1.charAt(n)==text2.charAt(m)){
            //当前两个的字符相同
            return 1+helper(text1,n+1,text2,m+1);
        }else {
            return Math.max(Math.max(helper(text1,n+1,text2,m+1),helper(text1,n+1,text2,m)),
                    helper(text1,n,text2,m+1));
        }
    }
}

• 那abcde 去匹配ace,我们发现e相同，那我们就肯定去那abcd去匹配ac,当d!=c.我们有三种情况可以选择，abc去匹配ac,或者abcd去匹配a,或者是abc去匹配a,选择匹配长度最长的那个选择
•  有个优化点，就是我们在比较较大的长度的时候，不需要比较helper(text1,n+1,text2,m+1),因为n+1,m+1的两个字符串的范围都是小于n+1,m和n,m+1的字符串长度，所以肯定是比这两个的公共子序列长度短
• 为什么不能从前往后递归，将语义变成前n个字符和前m个字符的最长公共序列的长度，因为我们在比较一个字符的时候，我们递归是依赖范围更小的递归函数，那就不对了，如果我们遇到一个不相同的字符，我们应该将当前字符跟后面的字符比，看能不能找到相同的字符，如果这样定义语义，我们就是跟前面的字符去比，这样就不对， 因为递归语义是前面的字符串都是比较好的，再去比是没有意义的

剪枝优化

class Solution {
  public int longestCommonSubsequence(String text1, String text2) {
        int n=text1.length();
        int m=text2.length();
        int dp[][]=new int[n+1][m+1];
        for (int []rows:dp) {
            Arrays.fill(rows,-1);
        }
            return helper(text1,0,text2,0,dp);
    }

    private int  helper(String text1, int n, String text2, int m, int[][] dp) {
        if(n==text1.length()||m==text2.length()){
            return 0;
        }
        if (dp[n][m]!=-1){
            return dp[n][m];
        }
        if(text1.charAt(n)==text2.charAt(m)){
            //当前两个的字符相同
            dp[n][m]= 1+helper(text1,n+1,text2,m+1, dp);
            return dp[n][m];
        }else {
            dp[n][m] =Math.max(helper(text1,n+1,text2,m, dp), helper(text1,n,text2,m+1, dp));
            return dp[n][m];
        }
    }
}

自底向上的动态规划

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int n=text1.length();
        int m=text2.length();
        int dp[][]=new int[n+1][m+1];
        for (int i =1; i <=n; i++) {
            for (int j =1; j <=m; 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[n][m];
    }
}

•  用函数 f(i, j) 表示字符串 s1 中下标从 0 开始到 i 的子字符串 s1[0...i] 和字符串 s2 中下标从 0 开始到 j 的子字符串 s2[0...j] 的最长公共子序列的长度。对于 f(i, j)，如果 s1[i] == s2[j]，那么相当于在 s1[0...i - 1] 和 s2[0...j - 1] 的最长公共子序列的后面添加一个公共字符，也就是 f(i, j) = f(i - 1, j - 1) + 1。如果 s1[i] != s2[j]，那么这两个字符不可能出现在 s1[0...i] 和 s2[0...j] 的公共子序列中。此时 s1[0...i] 和 s2[0...j] 的最长公共子序列是s1[0...i - 1] 和 s2[0...j] 的最长公共子序列和s1[0...i] 和 s2[0...j - 1] 的最长公共子序列中的较大值，即 f(i, j) = max(f(i - 1, j), f(i, j - 1))。所以转移状态方程为

不同的子序列 

 暴力枚举（自顶向下）+剪枝

class Solution {
     public int numDistinct(String s, String t) {
        int n=s.length();
        int m=t.length();
        int dp[][]=new int[n+1][m+1];
        for (int rows[]:dp) {
            Arrays.fill(rows,-1);
        }
        return helper(s,n,t,m,dp);
    }
    //递归函数的语义是s[0...n] t[0...m]的最大不同子序列数
    private int helper(String s, int n, String t, int m, int[][] dp) {
        if(m==0){
            return 1;
            //说明t为空串了，这个判断必须在n==s.length前面，保证m==0,n==0的时候返回1
        }
        if(n==0){
            return 0;
            //说明s是空串
        }
        if(dp[n][m]!=-1){
            return dp[n][m];
        }
        if (s.charAt(n-1)==t.charAt(m-1)){
            //当前字符相同 两种选择
            dp[n][m]= helper(s,n-1,t,m-1,dp)+helper(s,n-1,t,m, dp);
            return dp[n][m];
        }else {
            dp[n][m]=helper(s,n-1,t,m, dp);
            return dp[n][m];
        }
    }
}

 自底向上

class Solution {
         public int numDistinct(String s, String t) {
        int m=s.length();
        int n=t.length();
        int dp[][]=new int[n+1][m+1];
        for (int i = 0; i <=n; i++) {
            for (int j = 0; j <=m; j++) {
                if(i==0){
                    dp[i][j]=1;
                    continue;
                }
                if(j==0){
                    dp[i][j]=0;
                    continue;
                }
                if (s.charAt(j-1)==t.charAt(i-1)){
                    dp[i][j]=dp[i-1][j-1]+dp[i][j-1];
                }else {
                    dp[i][j]=dp[i][j-1];
                }
            }
        }
        return dp[n][m];
    }


}

300. 最长递增子序列

 

 

class Solution {
    public int lengthOfLIS(int[] nums) {
        int len=nums.length;
        int dp[]=new int [len];
        Arrays.fill(dp,1);//因为最短也就是本身
        for(int i=1;i<len;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<len;i++){
            res=Math.max(res,dp[i]);
        }
        return res;
    }
}

• dp[i]表示 从0到i的最长的递增子序列。

53. 最大子数组和

 

 

class Solution {
    public int maxSubArray(int[] nums) {
        int n=nums.length;
        if(n==0) return 0;
        int dp[]=new int [n];
        dp[0]=nums[0];
        for(int i=1;i<n;i++){
            dp[i]=Math.max(nums[i],nums[i]+dp[i-1]);
        }
        int res=Integer.MIN_VALUE;
        for(int i=0;i<n;i++){
            res=Math.max(res,dp[i]);
        }
        return res;
    }
}