代码随想录 - 动态规划 - 子序列，子数组

Leetcode300.最长递增子序列

力扣

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

解法：

代码随想录

动态规划，利用dp[i]保存以nums[i]结尾的最长递增子序列长度。

dp[i]更新：对于j从0到i - 1的取值，dp[i] = max(dp[j] + 1, dp[i]);

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> dp(nums.size(), 1);
        int res = 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[j] + 1, dp[i]);
            }
            res = max(res, dp[i]);
        }
        return res;
    }
};

674. 最长连续递增序列

力扣

给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。

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

718. 最长重复子数组

力扣

子数组：连续数组

输入：nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
输出：3
解释：长度最长的公共子数组是 [3,2,1] 。

解法：

dp[i][j]表示以nums1[i - 1]和nums2[j -1]为结尾的最长重复子数组的长度。

由于子数组需要连续，更新的时候只考虑nums1[i - 1] == nums2[j -1]时的情况

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        int res = 0;
        vector<vector<int>> dp(nums1.size() + 1, vector<int>(nums2.size() + 1, 0)); // 最长公共连续子数组长度
        for(int i = 1; i <= nums1.size(); i++){
            for(int j = 1; j <= nums2.size(); j++){
                if(nums1[i - 1] == nums2[j - 1]){
                    dp[i][j] = max(dp[i - 1][j - 1] + 1, dp[i][j]);
                }
                res = max(res, dp[i][j]);
            }
        }
        return res;
    }
};

1143. 最长公共子序列

力扣

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

• 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。

两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

解法：

子序列和子数组的区别是可以不连续！

因此dp数组存放的最长序列长度可以不包含ij

dp[i][j] = max(p[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1] + 1)

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int res = 0;
        vector<vector<int>> dp(text1.length() + 1, vector<int>(text2.length() + 1, 0)); // 以i, j结尾的最长公共子序列长度，可以不包括ij
        for(int i = 1; i <= text1.length(); i++){
            for(int j = 1; j <= text2.length(); j++){
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                if(text1[i - 1] == text2[j - 1]){
                    dp[i][j] = max(dp[i - 1][j - 1] + 1, dp[i][j]);
                }
                res = max(res, dp[i][j]);
            }
        }
        return res;

    }
};

1035. 不相交的线

力扣

在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。

现在，可以绘制一些连接两个数字 nums1[i] 和 nums2[j] 的直线，这些直线需要同时满足满足：

•  nums1[i] == nums2[j]
• 且绘制的直线不与任何其他连线（非水平线）相交。

请注意，连线即使在端点也不能相交：每个数字只能属于一条连线。

以这种方法绘制线条，并返回可以绘制的最大连线数。

解法：

转化为最长公共子序列

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

53. 最大子数组和

力扣

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

子数组 是数组中的一个连续部分。

解法1：

经典贪心算法

模拟人思考问题的思维。

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

392. 判断子序列

力扣

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

进阶：

如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

解法1：

动态规划：编辑距离问题

解法2：

经典双指针

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

115.不同的子序列

力扣题目链接(opens new window)

给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。

字符串的一个 子序列 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，"ACE" 是 "ABCDE" 的一个子序列，而 "AEC" 不是）

题目数据保证答案符合 32 位带符号整数范围。

解法：

要求所有子序列的个数，不能用双指针做。

动态规划：编辑距离问题