代码随想录训练营第五十二天|300.最长递增子序列、674.最长连续递增序列、718.最长重复子数组

300.最长递增子序列

链接：LeetCode300.最长递增子序列
子序列：子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7]是数组[0,3,1,6,2,2,7]的子序列。

1. 确定dp数组以及下标含义。dp[i]表示在下标为[0-i]的数组中最长递增子序列的元素个数。
2. 确定递推公式。if(nums[i]>nums[j]) dp[i] =max(dp[i],dp[j]+1);(0<j<i)
3. dp数组初始化。dp[i] = 1;(因为单独一个元素本身就是一个递增子序列)
4. 确定遍历顺序。从前往后遍历数组。
5. 举例推导dp数组

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> dp(nums.size(),1);
        int ans=1;
        for(int i=1;i<nums.size();++i){
            for(int j=0;j<i;++j){
                if(nums[i]>nums[j]) dp[i] = dp[i]>dp[j]+1?dp[i]:dp[j]+1;
            }
            ans = ans>dp[i]?ans:dp[i];
        }
        return ans;
    }
};

674.最长连续递增序列

链接：LeetCode674.最长连续递增序列
从下标为1的地方从前往后遍历数组，如果nums[i]>nums[i-1]就将res加1，否则将res变为1重新开始计数。

贪心

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        int ans = 1,res=1;
        for(int i=1;i<nums.size();++i){
            if(nums[i]>nums[i-1]) ++res;
            else res = 1;
            ans = ans>res?ans:res;
        }
        return ans;
    }
};

动态规划

1. 确定dp数组以及下标含义。dp[i]表示下标为[0-i]的数组中最长连续递增序列的子数组。
2. 确定递推公式.if(nums[i]>nums[i-1])dp[i] = dp[i-1]+1;
3. 数组初始化。dp[i] =1;
4. 确定遍历顺序。从前往后开始遍历。
5. 举例推导dp数组。

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        vector<int> dp(nums.size(),1);
        int ans=1;
        for(int i=1;i<nums.size();++i){
            if(nums[i]>nums[i-1]) dp[i] = dp[i-1]+1;
            ans = ans>dp[i]?ans:dp[i];
        }
        return ans;
    }
};

718.最长重复子数组

链接：LeetCode718.最长重复子数组

1. 确定dp数组以及下标含义。dp[i][j]表示下标为[0-i]的nums1数组和下标为[0-j]的nums2数组公共的长度最长的子数组的长度。
2. 确定递推公式.if(nums[i]==nums[j]) dp[i][j] = dp[i-1][j-1]+1;
3. 数组初始化。if(nums1[0]==nums2[j])dp[0][j] =1;if(nums1[i]==nums2[0]) dp[i][0]=1;
4. 确定遍历顺序。从前往后开始遍历。先遍历nums1后遍历nums2;
5. 举例推导dp数组。

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

第二版

与第一版的不同之处就是dp数组下标的含义。
dp[i][j]表示长度为i的nums1子数组和长度为j的nums2子数组中公共的、长度最长的子数组的长度。

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 ans=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;
                ans = max(ans,dp[i][j]);
            }
        }
        return ans;
    }
};

滚动数组

将第二版代码中，用第i-1层覆盖第i层。

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

        for(int i=1;i<=nums1.size();++i){
            for(int j=nums2.size();j>=1;--j){
                if(nums1[i-1]==nums2[j-1]) dp[j] =dp[j-1]+1;
                else dp[j] = 0;
                ans = ans>dp[j]?ans:dp[j];
            }
        }
        return ans;
    }
};

这一版代码需要注意的地方是：
当nums[i]!=nums[i-1]的情况下，要把dp[j]重置为0；
因为要求的是最长的公共子数组，子数组是连续的，一旦遇到一个不相同的值，需要从后面重新开始计数。
但是对于二维的dp数组不需要这一步操作，是因为二维dp数组没有被覆盖的情况，每一个状态都是独立的。