Day37：动态规划part10（300.最长递增子序列、674.最长连续递增序列 、718.最长重复子数组）

300.最长递增子序列

题目链接 ：https://leetcode.cn/problems/longest-increasing-subsequence/

给你一个整数数组 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

总结

定义 dp[i] 表示以 nums[i] 结尾的最长严格递增子序列的长度。

• 初始时，每个位置至少可以单独构成一个长度为 1 的子序列，所以 dp[i] = 1
• 对于每个 i，我们遍历所有 j < i：
  • 如果 nums[j] < nums[i]，说明可以把 nums[i] 接在以 nums[j] 结尾的递增子序列后面
  • 所以：dp[i] = max(dp[i], dp[j] + 1)

最后答案就是 max(dp[0], dp[1], ..., dp[n-1])

class Solution {
    public int lengthOfLIS(int[] nums) {
        int n = nums.length;
        if (n == 0) return 0;
        
        int[] dp = new int[n];
        Arrays.fill(dp, 1); // 每个元素自己就是一个长度为1的子序列
        
        int maxLength = 1;
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            maxLength = Math.max(maxLength, dp[i]);
        }
        
        return maxLength;
    }
}

674.最长连续递增序列

题目链接 ：https://leetcode.cn/problems/longest-continuous-increasing-subsequence/description/

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

连续递增的子序列 可以由两个下标 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

总结

• "连续 "：意味着子序列在原数组中是相邻的元素，不能跳着选。
• "递增 "：严格递增，即 nums[i] < nums[i+1]，相等不算递增。

滑动窗口 / 一次遍历

1. 初始化两个变量：
   • currentLength：当前连续递增序列的长度（至少为 1）
   • maxLength：记录历史最大长度
2. 从下标 1 开始遍历数组：
   • 如果 nums[i] > nums[i - 1]，说明还在递增，currentLength++
   • 否则，递增中断，重置 currentLength = 1
   • 每次更新 maxLength = Math.max(maxLength, currentLength)
3. 返回 maxLength

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        
        int maxLength = 1;        // 至少有一个元素
        int currentLength = 1;    // 当前连续递增长度
        
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > nums[i - 1]) {
                currentLength++;
            } else {
                currentLength = 1; // 重新开始计数
            }
            maxLength = Math.max(maxLength, currentLength);
        }
        
        return maxLength;
    }
}

动态规划思路

1. 定义状态

设 dp[i] 表示 以 nums[i] 结尾的最长连续递增子序列的长度。

注意：因为要求"连续"，所以 dp[i] 只能从 dp[i-1] 转移而来（不能跳着看前面的元素）。

2. 状态转移方程

• 如果 nums[i] > nums[i - 1]：

  • 可以接在前一个递增序列后面 → dp[i] = dp[i - 1] + 1

• 注意这里就体现出和动态规划：300.最长递增子序列 (opens new window)的区别！

  因为本题要求连续递增子序列，所以就只要比较nums[i]与nums[i - 1]，而不用去比较nums[j]与nums[i] （j是在0到i之间遍历）。

  既然不用j了，那么也不用两层for循环，本题一层for循环就行，比较nums[i] 和 nums[i - 1]。

3. 初始化

• 每个位置至少可以构成长度为 1 的序列 → dp[i] = 1 对所有 i

4. 答案

• 所有 dp[i] 中的最大值 → max(dp[0], dp[1], ..., dp[n-1])

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n];
        Arrays.fill(dp, 1);

        int maxl = 1; 
        for (int i = 1; i < n; i++) {
            if (nums[i] > nums[i - 1]) {
                dp[i] = dp[i - 1] + 1;
            }
            maxl = Math.max(maxl, dp[i]);
        }
        return maxl;
    }
}

注意到 dp[i] 只依赖于 dp[i-1]，所以我们不需要整个数组，只需一个变量保存前一个状态即可：

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        int n = nums.length;
        if (n == 0) return 0;
        
        int prev = 1; // dp[i-1]
        int maxLength = 1;
        
        for (int i = 1; i < n; i++) {
            int curr = (nums[i] > nums[i - 1]) ? prev + 1 : 1;
            maxLength = Math.max(maxLength, curr);
            prev = curr; // 更新 prev 为当前 dp 值
        }
        
        return maxLength;
    }
}

718.最长重复子数组

题目链接 ：https://leetcode.cn/problems/maximum-length-of-repeated-subarray/description/

给两个整数数组 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]为结尾的字符串 ）

如果定义dp[i][j]为以下标i为结尾的A，和以下标j为结尾的B，实现起来就麻烦一点，需要单独处理初始化部分。

2. 确定递推公式

根据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开始！

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，正好符合递推公式逐步累加起来。

4. 确定遍历顺序

外层for循环遍历A，内层for循环遍历B。

同时题目要求长度最长的子数组的长度。所以在遍历的时候顺便把dp[i][j]的最大值记录下来。

5. 代码实现

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int m = nums1.length;
        int n = nums2.length;
        int[][] dp = new int[m + 1][n + 1];
        int maxLen = 0;

        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (nums1[i - 1] == nums2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    maxLen = Math.max(maxLen, dp[i][j]);
                }
                // else: dp[i][j] = 0（默认值，无需显式赋值）
            }
        }

        return maxLen;
    }
}