代码随想录算法训练营day48

题目：300.最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组

300.最长递增子序列

思路：dp五部曲：dp数组，dp[i]表示以nums[i]结尾的最长子序列长度，这里的以nums[i]结尾 非常重要，因为这样和之前的比较才有意义，才能考虑进nums[i]，如果这个dp数组想不到，本题则无法切入；递推公式，以nums[i]结尾，需要比较以从0到i-1即前面每一位结尾的最长子序，如果nums[i]>nums[j]，则将以nums[j]结尾的最长子序+1，需要把前面的所有结尾都比较一遍，找出最大的，nums[i]=max(nums[i],nums[j]+1)；dp初始化，全部初始化为1，因为最小递增子序长度就是1；遍历顺序，从左往右；举例略。注意返回结果，不一定以最后一位结尾，故需要记录所有dp数组的最大值。时间复杂度O(n^2)。

cpp 复制代码

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> dp(nums.size(),1);//初始化最小都为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]=max(dp[i],dp[j]+1);
                }
            }
            ans=max(ans,dp[i]);
        }
        return ans;
    }
};

674. 最长连续递增序列

思路：本题和上题的区别是序列必须连续。dp五部曲：dp数组，dp[i]表示以nums[i]结尾的最长连续递增序列，在比较中需要用上nums[i]，故还是需要以i结尾；递推公式，这里只要和前一位比，如果nums[i]>nums[i-1]，则直接加1就行，否则依旧为1；初始化，全部为1；遍历顺序，从左往右；举例略。返回值需要用ans，在dp数组中取最大值。时间复杂度O(n)。

cpp 复制代码

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

718. 最长重复子数组

思路：本题要求两个数组最长重复子数组的长度，注意子数组指的是连续序列 。首先是暴力解法，即两层for确定数组启示位置，如果相同，则开始往后比较，获得最长重复子数组长度，时间复杂度O(n^3)。代码略，用不上。然后是dp五部曲：dp数组，这里有两个数组，需要设置二维dp，dp[i][j]表示A以i-1结尾，B以j-1结尾的最长重复子数组长度 ，这里的i-1和j-1在后面初始化的时候可以省略代码；递推公式，当A[i-1]和B[j-1]相等时，这时dp[i][j]=dp[i-1][j-1]+1；初始化，根据递推公式，遍历应该从i=1,j=1开始，dp[i][0]和dp[0][j]没有定义的，但是为了方便我们的代码初始化，我们可以给它们设置值为0，这样开始遍历的时候，当i,j>=1的时候，就能直接由递推公式往后算，例如A[0]=B[0]时，dp[1][1]=dp[0][0]+1这时算出来就是1，符合要求；遍历顺序，顺序遍历；举例如图所示。时间复杂度O(n*m)。

cpp 复制代码

	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++){//i=0,j=0已经初始化过了
            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]>ans){
                        ans=dp[i][j];//返回dp数组中的最大值
                    }
                }
            }
        }
        return ans;
    }
};

也就是说dp[0][j]和dp[i][0]是预留的0，专门方便初始化的。如果我们就不预留，用dp[i][j]表示以A[i]和B[j]结尾的最长重复子数组长度，则初始化的时候，还需要将A和B每一项一个个对比，相同置1，不相同置0，增加了代码复杂度。

看标答还可以用一维滚动数组优化空间复杂度，注意遍历数组B的时候要从后往前，最关键的地方就是当AB两个位置不同时，必须要置为0，在下一轮遍历，需要用到上一轮的dp计算结果，所以一定是从后往前，如果从前往后，则dp用的是这轮已经计算过的，存在重复计算，代码如下：

cpp 复制代码

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        vector<int> dp(nums2.size()+1,0);//只初始化一维数组
        int ans=0;
        for(int i=0;i<nums1.size();i++){
            for(int j=nums2.size();j>0;j--){//滚动数组要反着遍历
                if(nums1[i]==nums2[j-1]){
                    dp[j]=dp[j-1]+1;
                    if(dp[j]>ans){
                        ans=dp[j];//返回dp数组中的最大值
                    }
                }
                else{
                    dp[j]=0;//这一步非常关键，防止重复迭代，每一轮遍历都需要保证算出的dp数组是正确的
                }
            }   
        }
        return ans;
    }
};