代码随想录day52 | 动态规划P13 | ● 300. ● 674. ● 718.

300.最长递增子序列 

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4

示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1

思路

本题是子序列问题的初始问题, 需要想到dp的定义方式 dp的递推

首先dp[i] 代表以nums[i]结尾的最长递增子序列长度 

递推; 遍历 j 从0到 i -1, 当nums[ i ] > nums[ j ] 的时候, dp[ i ] = max(dp[i], dp[j] + 1) //取最大的dp[j] + 1

初始化: 全为1 因为至少包含它本身

代码

class Solution {
    public int lengthOfLIS(int[] nums) {
        //dp[i] 表示 以nums[i]结尾的最长递增子序列的长度
        int [] dp = new int [nums.length];
        int res = 1;
        Arrays.fill(dp, 1);
        for(int i = 1; i < nums.length; i++){
            for(int j = 0; j < i; j++){
                if(nums[i] > nums[j]) dp[i] = Math.max(dp[i], dp[j] + 1);
            }
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

674. 最长连续递增序列 

给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。

连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。

示例 1：

输入：nums = [1,3,5,4,7]
输出：3
解释：最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为 5 和 7 在原数组里被 4 隔开。 

示例 2：

输入：nums = [2,2,2,2,2]
输出：1
解释：最长连续递增序列是 [2], 长度为1。

思路

与lc300. 最长递增子序列的区别在于 本题要求连续

那么在递推的时候就不能遍历 j 从0 - i-1 取最大 只能取 j = i - 1 当nums[ i ] > nums[ i-1 ] 的时候, dp[ i ] = dp[ i-1 ] + 1

代码

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        int [] dp = new int [nums.length];
        int n = nums.length;
        Arrays.fill(dp,1);
        int res = 1;
        for(int i = 1; i < n; i++){
            if(nums[i] > nums[i-1]) dp[i] = dp[i-1] + 1;
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

718. 最长重复子数组 

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

示例 1：

输入：nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
输出：3
解释：长度最长的公共子数组是 [3,2,1] 。

示例 2：

输入：nums1 = [0,0,0,0,0], nums2 = [0,0,0,0,0]
输出：5

思路

注意这里的子数组 其实就是连续子序列

比较两个数组的子数组 那么需要二维dp(或滚动数组)

dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]。 （特别注意： “以下标i - 1为结尾的A” 标明一定是 以A[i-1]为结尾的字符串 ）

根据dp[i][j]的定义，dp[i][j]的状态只能由dp[i - 1][j - 1]推导出来。即当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;

根据递推公式可以看出，遍历i 和 j 要从1开始！

代码

二维dp:

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int n1 = nums1.length;
        int n2 = nums2.length;
        int res = 0;
        //这里的子数组，其实就是连续子序列。
        //dp[i][j]代表 以[i - 1]下标结尾的nums1 以下标[j - 1]结尾的nums2最长重复子数组的长度
        int [][] dp = new int [n1 + 1][n2 + 1];
        for(int i = 1 ; i <= n1; i++){
            for(int j = 1; j <= n2; j++){
                if(nums1[i-1] == nums2[j-1]){
                    dp[i][j] = dp[i-1][j-1] + 1;
                }
                res = Math.max(res, dp[i][j]);
            }
        }
        return res;
    }
}

滚动数组:

注意内层就要从后向前遍历，以免重复覆盖, 污染上一层的结果

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int n1 = nums1.length;
        int n2 = nums2.length;
        int res = 0;
        //这里的子数组，其实就是连续子序列。
        int [] dp = new int [n2 + 1];
        for(int i = 1 ; i <= n1; i++){
            for(int j = n2; j >= 1; j--){//滚动数组 内层反向
                if(nums1[i-1] == nums2[j-1]){
                    dp[j] = dp[j-1] + 1;
                }else{
                    dp[j] = 0;// 注意这里不相等的时候要有赋0的操作
                }
                res = Math.max(res, dp[j]);
            }
        }
        return res;
    }
}