day52 动态规划part13● 300.最长递增子序列 ● 674. 最长连续递增序列 ● 718. 最长重复子数组

 考虑到一般动态规划的写法是n方，为了降低复杂度，考虑每次假如选择当前数dp[i]对应最长的序列，就找前面上一个数（已经做递推的时候记录了上一个数的比他小的一个数，因为等于上一个比他小的数的序列长度（已经最大）加1，所以不一定是离当前数的比他小的最近的数）

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int len=nums.size();
        vector<int> nextp(len+1,0);
        vector<int> dp(len+1,1);
        if(nums.size()==0) return 0;
        dp[0]=1;
        nextp[0]=-1;
        for(int i=1;i<len;i++){
            nextp[i]=i-1;
        }
        for(int i=1;i<len;i++){
            for(int j=nextp[i];j!=-1;){
                if(nums[i]>nums[j])
                {dp[i]=max(dp[j]+1,dp[i]);
                nextp[i]=j;
                // cout<<" >"<<i<<" "<<j<<endl;
                break;
                }
                else{
                dp[i]=max(dp[i],1);
                j=nextp[j];
                // cout<<" <="<<i<<" "<<j<<endl;
                }


            }
        }
        return dp[len-1];
        
    }
};

题解其实是一般的n方动态规划写法。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int len=nums.size();

        vector<int> dp(len+1,1);
        if(nums.size()==0) return 0;

        int res=0;
        for(int i=1;i<len;i++){
            for(int j=0;j<i;j++){
                if(nums[i]>nums[j])
                {
                    dp[i]=max(dp[i],dp[j]+1);
                }
            


            }
            res=max(res,dp[i]);
        }
        return res;
        
    }
};

一遍过

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

 

因为本题要求连续递增子序列，所以就只要比较nums[i]与nums[i - 1]，而不用去比较nums[j]与nums[i] （j是在0到i之间遍历）。

既然不用j了，那么也不用两层for循环，本题一层for循环就行，比较nums[i] 和 nums[i - 1]。

贪心

这道题目也可以用贪心来做，也就是遇到nums[i] > nums[i - 1]的情况，count就++，否则count为1，记录count的最大值就可以了。

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;
    }
};

 概括来说：不连续递增子序列的跟前0-i 个状态有关，连续递增的子序列只跟前一个状态有关

  子数组是连续子序列。

看了题解。

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

dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]。 （特别注意： “以下标i - 1为结尾的A” 标明一定是 以A[i-1]为结尾的字符串 ）

2、确定递推公式

根据dp[i][j]的定义，dp[i][j]的状态只能由dp[i - 1][j - 1]推导出来。

即当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;

根据递推公式可以看出，遍历i 和 j 要从1开始！

其实就是两层for循环。

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

滚动数组版本：此时遍历B数组的时候，就要从后向前遍历，这样避免重复覆盖。

/ 版本二
class Solution {
public:
    int findLength(vector<int>& A, vector<int>& B) {
        vector<int> dp(vector<int>(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;
    }
};

如果定义 dp[i][j]为 以下标i为结尾的A，和以下标j 为结尾的B，那么 第一行和第一列毕竟要进行初始化，如果nums1[i] 与 nums2[0] 相同的话，对应的 dp[i][0]就要初始为1， 因为此时最长重复子数组为1。 nums2[j] 与 nums1[0]相同的话，同理。 会更麻烦些。

// 版本三
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;
    }
};