Day77（动态规划——子序列）

674、最长连续递增序列

给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l],nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。

因为要求的是连续的递增的子序列，所以nums[i]只需要和nums[i-1]比较大小，

dp[i]:表示以下标i为结尾的数组的连续递增的子序列长度为dp[i] 

Arrays.fill(dp,1);//初始化，因为自己本身也是一个递增序列

递推公式：

当nums[i]>nums[i-1]，那么说明当前元素可以构成连续递增数组，所以还要加上它们的前一个元素构成的最长连续递增子序列的长度，此时的转移方程为：dp[i]=dp[i-1]+1;

当nums[i]<=nums[i-1]，那么说明当前元素不能构成连续递增数组，而题目要求连续，递增的子序列，所以这时候相当于直接断开了，此时的转移方程为:dp[i]=1(直接变成初始化的状态)

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        int max=1;
        int []dp=new int[nums.length+1];//dp[i]:表示以下标i为结尾的数组的连续递增的子序列长度为dp[i]
        Arrays.fill(dp,1);//初始化
        for(int i=1;i<nums.length;i++){
            if(nums[i]>nums[i-1]){
                dp[i]=dp[i-1]+1;
            }else{
                dp[i]=1;
            }
            max=Math.max(max,dp[i]);
        }
        return max;
    }
}

 718、最长重复子数组

给两个整数数组 nums1 和 nums2 ，返回 两个数组中 公共的 、连续的、长度最长的子数组的长度 。

dp[i][j]:表示数组num1前i个元素和数组nums2前j个元素组成的最长公共子数组的长度。
初始化为0，所以就不用特地写

递推公式：

若当前两个元素值相同，即A[i] == B[i],则说明当前元素可以构成公共子数组，所以还要加上它们的前一个元素构成的最长公共子数组的长度(在原来的基础上加1),此时状态转移方程:dp[i][j]=dp[ i - 1][j - 1] +1。

若当前两个元素值不同，即A[i]!= B[i],则说明当前元素无法构成公共子数组。因为公共子数组必须是连续的，而此时的元素值不同，相当于直接断开了，此时状态转移方程:dp[i][j] = 0（直接变成初始化的状态）

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        //有两个数据类型——动态规划应该是二维数组 有点像背包的容量
        int max=0;
        //dp[i][j]:表示数组num1前i个元素和数组nums2前j个元素组成的最长公共子数组的长度
        int[][]dp=new int[nums1.length+1][nums2.length+1];
        for(int i=1;i<=nums1.length;i++){
            for(int j=1;j<=nums2.length;j++){
                if(nums1[i-1]==nums2[j-1]){
                    dp[i][j]=dp[i-1][j-1]+1;//递推公式是这样的,
                    //所以i和j从1开始取,这样就可以保证dp[0][0]
                    //i和j取到nums1.length和nums2.length,这样就可以保证dp[nums1.length-1][nums2.length-1]即数组的最后一位可以取到
                }else{
                    dp[i][j]=0;
                }
                max=Math.max(max,dp[i][j]);
            }
        }
        return max;
    }
}

1143、最长公共子序列 

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

• 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。

两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

初始化：dp[i][j]:表示字符串A的前i个[0,i)元素和字符串B的前j个[0,j)元素最长公共子序列为dp[i][j]因为我们所说的第1个字符，其实就是字符串的索引0，所以我们for循环从1开始。只有for循环是错位的概念，dp[i][j]还是正常的位置

递推公式：

把text1设为数组A，text2设为数组B进行说明

若当前两个元素值相同，即A[i] == B[i],则说明当前元素可以构成公共子序列，所以还要加上它们的前一个元素构成的最长公共子序列的长度(在原来的基础上加1),此时状态转移方程:dp[i][j]=dp[ i - 1][j - 1] +1。

若当前两个元素值不同，即A[i]!= B[i]，因为题目定义的是子序列，所以就找text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。

即：当前两个字符不等，那么长度最少也是dp[i-1][i-1]，但这还不够，因为我们希望拿到之前的比较中尽可能大的长度。那么当前字符已经不相等的情况下，就应该把当前的字符也放入到之前的比较中，那么一定有dp[i][j-1]和dp[i-1][j]>=dp[ i ][ j ]。

简单来说，dp[ i ][ j ]的值应该从dp[i-1][j-1]、dp[i-1][j]、dp[i][j-1]中取

故：例子：abcd 和ac  当遍历最后一个字符时，d与c不相等，所以找前序的最长公共子序列，abcd和a的的公共子序列   acd和ac的公共子序列找最大的

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