DAY56：动态规划（子序列系列）300\674\718

Leetcode: 300 最长递增子序列

1、dp定义

dp[i]表示i之前包括i的以nums[i]结尾的最长递增子序列的长度。

2、状态转移方程

if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);

为0到i-1的最长子序列加1.

3、初始化

dp[0] =1;这个很好理解。

4、递归顺序

从前向后

时间复杂度: O(n^2)

空间复杂度: O(n)

代码如下：

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        if(nums.size() <= 1) return nums.size();//注意特殊情况的处理
        vector<int> dp(nums.size(), 1);
        int result = 1;
        for(int i = 1; i < nums.size(); i++){
            for(int j = 0; j < i; j++){
                if(nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
            }
            if(result < dp[i]) result = dp[i];//要取最长的子序列
        }
        return result;

    }
};

Leetcode: 674 最长连续递增序列

与上题的要求不同，这题要求连续最长。

因此状态状态公式变成if(nums[i] > nums[i - 1]) dp[i] = dp[i - 1] + 1;

时间复杂度：O(n)

空间复杂度：O(n)

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        if(nums.size() <= 1) return nums.size();
        vector<int> dp(nums.size(), 1);
        int result = 1;
        for(int i = 1; i < nums.size(); i++){
            if(nums[i] > nums[i - 1]) dp[i] = dp[i - 1] + 1;
            if(dp[i] > result) result = dp[i];//寻找最长的子序列
        }
        return result;

    }
};

也可以用贪心来做，空间复杂度降低为O(1)，代码如下：

代码随想录

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        int result = 1; // 连续子序列最少也是1
        int count = 1;
        for (int i = 1; i < nums.size(); i++) {
            if (nums[i] > nums[i - 1]) { // 连续记录
                count++;
            } else { // 不连续，count从头开始
                count = 1;
            }
            if (count > result) result = count;
        }
        return result;
    }
};

Leetcode: 718 最长重复子数组

 这题需要用到二维dp数组。

1、确定数组和下标的定义

dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]。

dp[0][0]没有定义，所以i,j要从1开始。

2、确定状态转移公式

只有A和B元素相等的时候，dp[i][j] = dp[i-1][j-1] + 1;

3、初始化

因为dp[0][0]没有定义初始化为0，同时dp[i][0]和dp[0][j]也没有含义，所以初始化为0。

4、遍历顺序

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

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

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        vector<vector<int>> dp(nums1.size() + 1,vector<int>(nums2.size() + 1, 0));
        int result = 0;
        for(int i = 1; i <= nums1.size(); i++){
            for(int j = 1; j <= nums2.size(); j++){
                if(nums1[i - 1] == nums2[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
                if(dp[i][j] > result) result = dp[i][j];
            }
        }
        return result;

    }
};

同样可以采用滚动数组的方法来减少空间复杂度。参照

代码随想录

如果dp[i][j] ：以下标i为结尾的A，和以下标j为结尾的B，最长重复子数组长度为dp[i][j]。代码实现上需要多一行初始化的过程。

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        vector<vector<int>> dp (nums1.size() + 1, vector<int>(nums2.size() + 1, 0));
        int result = 0;

        // 要对第一行，第一列经行初始化
        for (int i = 0; i < nums1.size(); i++) if (nums1[i] == nums2[0]) dp[i][0] = 1;
        for (int j = 0; j < nums2.size(); j++) if (nums1[0] == nums2[j]) dp[0][j] = 1;

        for (int i = 0; i < nums1.size(); i++) {
            for (int j = 0; j < nums2.size(); j++) {
                if (nums1[i] == nums2[j] && i > 0 && j > 0) { // 防止 i-1 出现负数
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }
                if (dp[i][j] > result) result = dp[i][j];
            }
        }
        return result;
    }
};