LeetCode刷题day25——动态规划

Jessie_waverider

已于 2024-12-24 16:33:48 修改

阅读量619

点赞数 7

文章标签： leetcode 动态规划算法

于 2024-12-13 21:38:25 首次发布

本文链接：https://blog.youkuaiyun.com/Screaming_Queen/article/details/144460450

版权

LeetCode刷题day25——动态规划

子序列问题（不连续）

300. 最长递增子序列

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4

示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1

提示：

1 <= nums.length <= 2500
-104 <= nums[i] <= 104

进阶：

你能将算法的时间复杂度降低到 O(n log(n)) 吗?（哈哈，我还不想）

分析：

dp[i]的定义是：表示以 nums[i]结尾的最长递增子序列的长度。(前面有dp[i]-1个比nums[i]小的元素)

动态规划方程：dp[i] = max(dp[i], dp[j] + 1);

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int maxLen = 0;
        vector<int> dp(nums.size(), 1);
        // 每个元素自己单独成为一个序列，所以全部初始化为0
        // dp[i]的定义是：表示以 nums[i]
        // 结尾的最长递增子序列的长度。前面有dp[i]-1个比nums[i]小的元素
        for (int i = 0; i < nums.size(); i++) {
            for (int j = i; j >= 0; j--) { // 从i这个元素往回看
                if (nums[i] > nums[j])
                    dp[i] = max(dp[i], dp[j] + 1);
                maxLen = max(maxLen, dp[i]); // 只是记录最大的结果
            }
        }
        return maxLen;
    }
};

1143. 最长公共子序列

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

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

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

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

示例 1：

输入：text1 = "abcde", text2 = "ace" 
输出：3  
解释：最长公共子序列是 "ace" ，它的长度为 3 。

示例 2：

输入：text1 = "abc", text2 = "abc"
输出：3
解释：最长公共子序列是 "abc" ，它的长度为 3 。

示例 3：

输入：text1 = "abc", text2 = "def"
输出：0
解释：两个字符串没有公共子序列，返回 0 。

提示：

1 <= text1.length, text2.length <= 1000
text1 和 text2 仅由小写英文字符组成。

分析：

天呐，我自己能写出来这东西？？666，真厉害我！！！

dp[i][j]:长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]。
子问题：0行和0列全部初始化为0.因为我们是从左上斜推到的结果。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

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

1035. 不相交的线

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

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

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

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

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

示例 1：

输入：nums1 = [1,4,2], nums2 = [1,2,4]
输出：2
解释：可以画出两条不交叉的线，如上图所示。 
但无法画出第三条不相交的直线，因为从 nums1[1]=4 到 nums2[2]=4 的直线将与从 nums1[2]=2 到 nums2[1]=2 的直线相交。

示例 2：

输入：nums1 = [2,5,1,2,5], nums2 = [10,5,2,1,5,2]
输出：3

示例 3：

输入：nums1 = [1,3,7,1,7,5], nums2 = [1,9,2,5,1]
输出：2

提示：

1 <= nums1.length, nums2.length <= 500
1 <= nums1[i], nums2[j] <= 2000

分析：

可恶，差点被这题骗了呜呜呜呜~~

首先，需要找到相等元素对

其次，连起来。但是，如何保证不交叉？假设你选中的是 nums1[i] 和 nums2[j] 之间的连接。如果你再选中 nums1[k] 和 nums2[l] 之间的连接，那么只有 i < k 且 j < l 时，它们才是合法的。也就是说，第二条线的起点和终点必须在第一条线的起点和终点之后。有点难吧？但是，**最长公共子序列（LCS）**天然就满足这个条件。是的，这个题的代码和上一题一样，啥也没改。。。。。shit

class Solution {
public:
    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size(), n = nums2.size();
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; 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[m][n];
    }
};

子序列问题（连续）

674. 最长连续递增序列(16号补完）

(https://leetcode.cn/problems/longest-continuous-increasing-subsequence/)

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

连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。

示例 1：

输入：nums = [1,3,5,4,7]
输出：3
解释：最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为 5 和 7 在原数组里被 4 隔开。

示例 2：

输入：nums = [2,2,2,2,2]
输出：1
解释：最长连续递增序列是 [2], 长度为1。

提示：

1 <= nums.length <= 104
-109 <= nums[i] <= 109

分析：

贪心法：

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        int i=0,j=1;
        int maxLen=0;

        while(i<nums.size()&&j<nums.size()){
            int pre=nums[i];
            while(j<nums.size()&&pre<nums[j]) {
                pre = nums[j];
                j++;
            }
            maxLen=max(maxLen,j-i);
            i=j++;
        }
        return maxLen==0?1:maxLen;
    }
};

动态规划法：

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

718. 最长重复子数组(16号补完）

(https://leetcode.cn/problems/maximum-length-of-repeated-subarray/)

给两个整数数组 nums1 和 nums2 ，返回 两个数组中 公共的 、长度最长的子数组的长度 。

示例 1：

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

示例 2：

输入：nums1 = [0,0,0,0,0], nums2 = [0,0,0,0,0]
输出：5

提示：

1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 100

分析：

动态规划法：

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        int len1=nums1.size(), len2=nums2.size();
        vector<vector<int>> dp(len1+1, vector<int>(len2+1, 0));
        int maxLen=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;
                else
                    dp[i][j] = 0;
                maxLen=max(maxLen,dp[i][j]);
            }
        }
        
        return maxLen;
            
    }
};

53. 最大子数组和

(https://leetcode.cn/problems/maximum-subarray/)

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

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

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

示例 2：

输入：nums = [1]
输出：1

示例 3：

输入：nums = [5,4,-1,7,8]
输出：23

提示：

1 <= nums.length <= 105
-104 <= nums[i] <= 104

**进阶：**如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的 分治法 求解。

分析：

似曾相识，贪心法做过，附上代码

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

现在来尝试动态规划，天才啊，十分钟，成功！！！

dp[i]：表示以nums[i-1]结尾的连续子序列，最大序列和为dp[i]。
动态规划方程：dp[i] = max(nums[i - 1], nums[i - 1] + dp[i - 1]);//要么从自己开始dp[i] = nums[i - 1];要么和前面的连上dp[i] = nums[i - 1] + dp[i - 1];

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

        int maxLen = INT_MIN;
        for (int i = 1; i <= len; i++)
            maxLen = max(maxLen, dp[i]);
        return maxLen;
    }
};