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

392.判断子序列
题目
给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

按照顺序 — 双指针

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int m = s.length(), n = t.length();
        int i = 0, j = 0;
        while (i < m && j < n) {
            if (s[i] == t[j]) {
                i++;
            }
            j++;
        }
        return i == m;
    }
};

动态规划

dp[i][j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度
if(s[i-1] == t[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
if (s[i - 1] != t[j - 1])，此时相当于t要删除元素，t如果把当前元素t[j - 1]删除，那么dp[i][j] 的数值就是 看s[i - 1]与 t[j - 2]的比较结果了，即：dp[i][j] = dp[i][j - 1];

递推公式与公共子序列非常的相似，但是因为是判断s是不是t的子序列 所以 能够删除的只有t 而公共子序列是两个都能删除取max

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int n = s.size();
        int m = t.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(s[i-1] == t[j-1]){
                    dp[i][j] = dp[i-1][j-1] + 1;
                }else dp[i][j] = dp[i][j-1];
            }
        }
        if(dp[n][m] == n) return true;
        return false;
    }
};

115. 不同的子序列