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

提示：

• 1 <= nums.length <= 2500
• -10^4 <= nums[i] <= 104

动规五部曲：

1、dp[i]的定义：dp[i]表示i之前包括i的以nums[i]结尾的最长递增子序列的长度；

2、状态转移方程：位置i的最长升序子序列等于 j 从 0 到 i-1 各个位置的最长升序子序列 + 1 的最大值。所以：if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1)；

3、初始化：每一个i，对应的dp[i]（即最长递增子序列）起始大小至少都是1；

4、确定遍历顺序：dp[i] 是有0到 i-1 各个位置的最长递增子序列推导而来，那么遍历i一定是从前向后遍历。j其实就是遍历0到i-1，那么是从前到后，还是从后到前遍历都无所谓，只要吧 0 到 i-1 的元素都遍历了就行了。 所以默认习惯 从前向后遍历。

5、举例推导dp数组，输入：[0,1,0,3,2]，dp数组的变化如下：

class Solution {
    public int lengthOfLIS(int[] nums) {
        int[] dp = new int[nums.length];
        // Arrays.fill(dp, 1); //高级写法，自己写不出来
        for(int i=0; i<nums.length; i++){
            dp[i] = 1;
        }

        for(int i=1; i<nums.length; i++){
            for(int j=0; j<= i-1; j++){
                if(nums[j]<nums[i]){
                    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;
    }
}

本题最关键的是要想到dp[i]由哪些状态可以推出来，并取最大值，那么很自然就能想到递推公式：dp[i] = max(dp[i], dp[j] + 1);

注意不能写成dp[i] = dp[j] + 1。因为还要保存前面递推时得出的最大结果。

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。

提示：

• 0 <= nums.length <= 10^4
• -10^9 <= nums[i] <= 10^9

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        int[] dp = new int[nums.length];
        // Arrays.fill(dp, 1); //高级写法，自己写不出来
        for(int i=0; i<nums.length; i++){
            dp[i] = 1;
        }

        for(int i=1; i<nums.length; i++){
            if(nums[i-1]<nums[i]){
                dp[i] = dp[i-1]+1;
            }
        
        }
        int res = 0;
        for (int i = 0; i < dp.length; i++) {
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

和上题相比，只是递推公式有了一些改变。也可以用贪心来解决，也就是遇到nums[i] > nums[i - 1]的情况，count就++，否则count为1，记录count的最大值就可以了。

718、最长重复子数组 

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

示例：

输入：

• A: [1,2,3,2,1]
• B: [3,2,1,4,7]
• 输出：3
• 解释：长度最长的公共子数组是 [3, 2, 1] 。

提示：

• 1 <= len(A), len(B) <= 1000
• 0 <= A[i], B[i] < 100

动规五部曲：

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

2、确定递推公式：即当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1; 根据递推公式可以看出，遍历i 和 j 要从1开始！

3、dp数组的初始化：根据dp[i][j]的定义，dp[i][0] 和dp[0][j]其实都是没有意义的！但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;所以dp[i][0] 和dp[0][j]初始化为0。举个例子A[0]如果和B[0]相同的话，dp[1][1] = dp[0][0] + 1，只有dp[0][0]初始为0，正好符合递推公式逐步累加起来。

如果定义 dp[i][j]为 以下标i为结尾的A，和以下标j 为结尾的B，那么 第一行和第一列毕竟要进行初始化，如果nums1[i] 与 nums2[0] 相同的话，对应的 dp[i][0]就要初始为1， 因为此时最长重复子数组为1。 nums2[j] 与 nums1[0]相同的话，同理。

4、遍历顺序

5、举例子推导

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int res = 0; //在循环的过程中判断得到res
        int[][] dp = new int[nums1.length + 1][nums2.length + 1];

        for(int i=1; i<nums1.length+1; i++){
            for(int j=1; j<nums2.length+1; 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;
    }
}

可以压缩为一维数组，dp[i][j]都是由dp[i - 1][j - 1]推出。那么压缩为一维数组，也就是dp[j]都是由dp[j - 1]推出。也就是相当于可以把上一层dp[i - 1][j]拷贝到下一层dp[i][j]来继续用。此时遍历B数组的时候，就要从后向前遍历，这样避免重复覆盖。