day 52 子序列问题

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

300. 最长递增子序列

1. dp[i]定义：以nums[i]结尾的最长递增子序长度
2. 递推公式:if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
   num[i] 之前各个位置，如果满足单调条件 取最大的一个
3. 初始化 vectordp(nums.size(), 1);

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

    }

};

674. 最长连续递增序列
关键点：连续单调---->一旦断开，就是一新的开始

1. 区间双指针

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        int result = 1;
        int start=0;
        int end=1;
        while(end < nums.size()){
            if(nums[end] <= nums[end-1]){
                result = max(result, end - start);
                start = end;
            }
            end++;
        }
        return max(result, end - start);
    }
};

2. dp[i]定义：以nums[i]结尾连续的最长递增子序长度
3. 递推公式:if (nums[i] > nums[j]) dp[i] = dp[i-1] + 1;
   如果 nums[i] > nums[i - 1]，那么以 i 为结尾的连续递增的子序列长度 一定等于 以i - 1为结尾的连续递增的子序列长度 + 1 。
4. 初始化 vectordp(nums.size(), 1);

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

最长重复子序列：必须是连续的 -----> 相等就加一 不相等就为0

最长公共子序列: 只需要保持顺序就可以---->相等加一，不相等子集找最大的

718. 最长重复子数组

1. dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度
2. 递推公式： 当A[i] 和B[j]相等的时候，dp[i+1][j+1] = dp[i][j] + 1;
   不相等的时不需要处理 就是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++){
            for(int j=0; j<nums2.size(); j++){
                if(nums1[i] == nums2[j]){
                    dp[i+1][j+1] = dp[i][j] + 1;
                }
                result = max(result, dp[i+1][j+1]);

            }
        }
        return result;
    }
};

1143. 最长公共子序列

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int n = text1.size();
        int m = text2.size();
        vector<vector<int>>dp(n+1, vector<int>(m+1, 0));
        for(int i=1; i<=n; i++){
            for(int j=1; j<=m; j++){
                if(text1[i-1] ==  text2[j-1]){
                    dp[i][j] = dp[i-1][j-1] + 1;
                }else dp[i][j] = max(dp[i][j-1], dp[i-1][j]);
            }
        }
        return dp[n][m];
    }
};

1035. 不相交的线
直线不能相交，这就是说明在字符串A中 找到一个与字符串B相同的子序列，且这个子序列不能改变相对顺序，只要相对顺序不改变，链接相同数字的直线就不会相交。
跟最长公共子序列是一样的。就是找一个固定的顺序，而且是最长的。一模一样

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

53. 最大子数组和
题目：给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

1. 贪心
   如果当前加和为负数，就连翻盘的机会都没有直接清零，从当前加

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int cnt = nums[0];
        int max = cnt;
        for(int i=1; i<nums.size(); i++){
            if(cnt < 0){
                cnt = nums[i];  
            }else{
                cnt += nums[i];
            }
            if(cnt > max){
                max = cnt;
            }
        }
        return max;
    }
};

2. 动态规划
   dp[i]：包括下标i（以nums[i]为结尾）的最大连续子序列和
   dp[i] = max(dp[i - 1] + nums[i], nums[i]);

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n = nums.size();
        int result = INT_MIN;
        vector<int>dp(n+1, INT_MIN);
        dp[0] = 0;
        for(int i=1; i<=n; i++){
            dp[i] = max(dp[i-1] + nums[i-1], nums[i-1]);
            result = max(dp[i], result);
        }

        return result;
    }
};