day43|300.最长递增子序列, 674. 最长连续递增序列, 718. 最长重复子数组

300.最长递增子序列

300. 最长递增子序列 - 力扣（LeetCode）

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        vector<int> dp(n, 1);   // 已nums[i]为结尾的最长严格递增子序列
        int ans = 0;
        for(int i = 0; i < n; i++){
            for(int j = 0; j < i; j++){
                if(nums[j] < nums[i]){
                    dp[i] = max(dp[i], dp[j] + 1);
                }
            }
            ans = max(ans, dp[i]); // 取长
        }
        return ans;
    }
};

抄答案 

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        vector<int> d(n);
        d[0] = nums[0];
        int len = 0;
        for(int i = 0; i < n; i++){
            if(nums[i] > d[len]){
                d[++len] = nums[i]; // 增加长度
            }else{
                int l = 0, r = len, pos = 0; // 二分法插入数据
                while(l <= r){
                    int mid = (l + r) >> 1;
                    if(d[mid] < nums[i]){
                        pos = mid + 1;
                        l = mid + 1;
                    }else{
                        r = mid - 1;
                    }
                }
                d[pos] = nums[i];  // 不改变长度
            }
        }
        return len + 1;
    }
};

674. 最长连续递增序列

674. 最长连续递增序列 - 力扣（LeetCode）

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        int ans = 1, n = nums.size();
        vector<int> dp(n, 1);   // 以nums[i]为结尾的最长递增子序列
        for(int i = 1; i < n; i++){
            if(nums[i] > nums[i - 1]){
                dp[i] = dp[i - 1] + 1;
            }
            ans = max(ans, dp[i]);
        }
        return ans;
    }
};

718. 最长重复子数组

718. 最长重复子数组 - 力扣（LeetCode）

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size(), n = nums2.size(), ans = 0;
        vector<vector<int>> dp(m, vector<int>(n, 0));  // 以i, j结尾的子数组长度
        for(int i = 0; i < m; i++){
            if(nums1[i] == nums2[0]){
                dp[i][0] = 1;
            }
            ans = max(dp[i][0], ans);
        }
        for(int i = 0; i < n; i++){
            if(nums2[i] == nums1[0]){
                dp[0][i] = 1;
            }
            ans = max(dp[0][i], ans);
        }
        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
                if(nums1[i] == nums2[j]){
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }else{
                    dp[i][j] = 0;
                }
                ans = max(dp[i][j], ans);
            }
        }
        return ans;
     }
};