第九章 动态规划part10

最长递增子序列

题目描述

给你一个整数数组 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. 确定dp数组以及下标的含义

   • dp[i] 表示以 nums[i] 结尾的最长上升子序列的长度。

2. 确定递推公式

   • 如果 nums[i] > nums[j]（j < i），那么可以将 nums[i] 添加到以 nums[j] 结尾的上升子序列的末尾，因此递推公式为：

     dp[i] = max(dp[i], dp[j] + 1)

3. dp数组初始化

   • 每个元素自身至少可以构成一个长度为1的上升子序列。因此，所有 dp[i] 初始化为 1。

4. 确定遍历顺序

   • 外层循环需要从左到右遍历数组 nums，在内层循环中对于每个 i，再遍历 i 之前的所有元素 j（0 <= j < i），保证在计算 dp[i] 时已经计算了所有 dp[j]，

5. 举例推导dp数组

   • 以示例二为例，输入 [0,1,0,3,2,3] ，手推dp数组状态图如下：

     

代码实现

测试地址：https://leetcode.cn/problems/longest-increasing-subsequence/

class Solution {
public:
    int lengthOfLIS(vector<int> &nums) {
        int len = nums.size();
        int ans = 1;  // 存储最长上升子序列的长度，起始长度为1（至少包含一个元素）
        if (len == 0)
            return 0;  // 如果数组为空，则最长上升子序列长度为0

        vector<int> dp(len, 1);  // dp数组，dp[i]表示以nums[i]结尾的最长上升子序列长度
  
        // 外层循环遍历所有数组元素
        for (int i = 1; i < len; i++) {
            // 内层循环对比当前元素nums[i]与之前元素nums[j]
            for (int j = 0; j < i; j++) {
                // 如果当前元素大于之前的某个元素，尝试更新dp[i]
                if (nums[i] > nums[j]) {
                    dp[i] = max(dp[i], dp[j] + 1);
                }
            }
            // 更新全局最长上升子序列长度
            ans = max(ans, dp[i]);
        }
        return ans;  // 返回最大长度
    }
};

最长连续递增序列

题目描述

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

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

解题思路

1. 确定dp数组以及下标的含义

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

2. 确定递推公式

   • 如果当前元素 nums[i] 大于前一个元素 nums[i - 1]，那么以当前元素为结尾的最长连续递增子序列的长度就可以由以前一个元素为结尾的最长递增子序列的长度 dp[i - 1] 加一得到。这是因为 nums[i] 可以接在前一个元素的递增子序列后面，形成一个更长的递增子序列。
   • 递推公式：dp[i] = dp[i - 1] + 1

3. dp数组初始化

   • 初始化dp数组时，将每个元素设置为1，因为每个元素自身可以视为长度为1的递增子序列。

4. 确定遍历顺序

   • 根据递推公式可以得知，dp[i] 依赖于 dp[i-1]，因此遍历顺序为从小到大。

5. 举例推导dp数组

   • 以示例一为例，输入[1,3,5,4,7]，手推dp数组状态图：

     

代码实现

测试地址：https://leetcode.cn/problems/longest-continuous-increasing-subsequence/

class Solution {
public:
    int findLengthOfLCIS(vector<int> &nums) {
        int len = nums.size(); // 获取数组长度
        if (len <= 1) // 若数组长度小于等于1，直接返回长度
            return len;
    
        int ans = 0; // 用于记录最长连续递增子序列的长度
        vector<int> dp(len, 1); // 初始化dp数组，每个元素初始值为1
    
        for (int i = 1; i < len; i++) { // 从第二个元素开始遍历数组
            if (nums[i] > nums[i - 1]) { // 若当前元素大于前一个元素
                dp[i] = dp[i - 1] + 1; // 则以当前元素为结尾的递增子序列长度为前一个元素的长度加1
            }
            ans = max(ans, dp[i]); // 更新最长连续递增子序列的长度
        }
    
        return ans; // 返回最长连续递增子序列的长度
    }
};

最长重复子数组

题目描述

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

解题思路

1. 确定dp数组以及下标的含义

   • dp[i][j]表示以nums1[i-1]和nums2[j-1]结尾的最长公共子数组的长度。
   • 这里使用i-1和j-1是为了简化边界处理，使得dp[0][0]自然为0，表示两个空数组的最长公共子数组长度。

2. 确定递推公式

   • 如果nums1的第i-1个元素和nums2的第j-1个元素相等，那么以这两个元素结尾的最长公共子数组的长度就是以nums1[i-2]和nums2[j-2]结尾的最长公共子数组的长度加1。
   • 如果这两个元素不相等，那么以这两个元素结尾的最长公共子数组的长度为0，因为它们不能形成公共子数组。
   • 递推公式：在满足nums1[i-1] == nums2[j-1]的情况下，dp[i][j] = dp[i-1][j-1] + 1

3. dp数组初始化

   • dp数组初始化为全0，这样可以确保在处理边界情况时，dp[i][0]和dp[0][j]自然为0，表示一个数组为空，另一个数组不为空的情况。

4. 确定遍历顺序

   • 从nums1和nums2的第一个元素开始，逐个比较它们的元素。
   • 每次比较nums1[i-1]和nums2[j-1]是否相等，如果相等则更新dp[i][j]，否则保持为0。
   • 每次更新dp[i][j]后，都需要检查dp[i][j]是否大于result，如果是则更新result为当前的dp[i][j]值。

5. 举例推导dp数组

   • 以示例1中，A: [1,2,3,2,1]，B: [3,2,1,4,7]为例，手推dp数组状态图如下：

     

代码实现

测试地址：https://leetcode.cn/problems/maximum-length-of-repeated-subarray/

class Solution {
public:
    int findLength(vector<int> &nums1, vector<int> &nums2) {
        // 创建一个二维数组dp，大小为(nums1.size() + 1) x (nums2.size() + 1)，初始值为0
        vector<vector<int>> dp(nums1.size() + 1, vector<int>(nums2.size() + 1, 0));
        // 用于记录最长公共子数组的长度
        int ans = 0;
    
        // 遍历nums1的每个元素
        for (int i = 1; i <= nums1.size(); i++) {
            // 遍历nums2的每个元素
            for (int j = 1; j <= nums2.size(); j++) {
                // 如果nums1[i-1]和nums2[j-1]相等
                if (nums1[i - 1] == nums2[j - 1]) {
                    // 更新dp[i][j]为dp[i-1][j-1] + 1
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }
                // 更新ans为当前ans和dp[i][j]中的较大值
                ans = max(ans, dp[i][j]);
            }
        }
        // 返回最长公共子数组的长度
        return ans;
    }
};