代码训练营第55天：动态规划part13｜leetcode300最长递增子序列｜leetcode674最长连续递增子序列｜leetcode718最长重复子数组

leetcode300：最长递增子序列

文章讲解：leetcode300

leetcode674：最长连续递增子序列

文章讲解：leetcode674

leetcode718：最长重复子数组

文章讲解：leetcode718

目录

1，leetcode300 最长递增子序列

2，leetcode674 最长连续递增子序列

3，leetcode718 最长重复子数组

---

1，leetcode300 最长递增子序列

这道题其实递推思路比较容易想到，但是再算dp[i]的时候也是需要往前看的，这是麻烦的地方。

class Solution {
public:
    int lengthOfLIS(vector& nums) {
        if (nums.size() <= 1) return nums.size();
        vector dp(nums.size(), 1);
        int result = 0;
        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 (dp[i] > result) result = dp[i]; 
        }
        return result;
    }
};

2，leetcode674 最长连续递增子序列

这道题其实是难度提示了我，dp数组含义不用变，但是只需要向前看一个即可。

class Solution {
public:
    int findLengthOfLCIS(vector& nums) {
        vectordp(nums.size(),1);
        int result = 1;
        for(int i = 1;i

3，leetcode718 最长重复子数组

我的思路是dp[i][j]的含义是第一个数组到i，第二个数组到j时他们的最长重复子数组的含义。

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

拿下。

更简洁的方法是，让dp[i][j]表示i-1/j-1时的最长重复子数组，这样就省去了很多麻烦的初始化操作。

class Solution {
public:
    int findLength(vector& nums1, vector& nums2) {
        vector> dp (nums1.size() + 1, vector(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;
    }
};

// 版本二
class Solution {
public:
    int findLength(vector& A, vector& B) {
        vector dp(vector(B.size() + 1, 0));
        int result = 0;
        for (int i = 1; i <= A.size(); i++) {
            for (int j = B.size(); j > 0; j--) {
                if (A[i - 1] == B[j - 1]) {
                    dp[j] = dp[j - 1] + 1;
                } else dp[j] = 0; // 注意这里不相等的时候要有赋0的操作
                if (dp[j] > result) result = dp[j];
            }
        }
        return result;
    }
};

滚动数组方法有点难了。