代码随想录第二十四天|动态规划（8）

最新推荐文章于 2024-09-14 22:25:23 发布

はしもとかんな.

最新推荐文章于 2024-09-14 22:25:23 发布

阅读量1k

点赞数 11

文章标签：动态规划算法

本文链接：https://blog.csdn.net/qq_49711625/article/details/141071180

版权

LeetCode 300. 最长递增子序列

LeetCode 674. 最长连续递增序列

LeetCode 718. 最长重复子数组

LeetCode 1143. 最长公共子序列

LeetCode 300. 最长递增子序列

题目链接：LeetCode 300. 最长递增子序列

思想：依然用动归五部曲来分析，第一个dp数组的定义。这里把dp[i]表示i之前包括i的以nums[i]结尾的最长递增子序列的长度。在做递增比较的时候，比较两个子序列的结尾才能算递增，比较完一个再比较结尾也可以保证是递增的。其次就是状态转移方程，位置i的最长升序子序列等于j从0到i-1各个位置的最长升序子序列+1的最大值。所以状态转移方程是if(nums[i] > nums[j]) dp[i]=max(dp[i],dp[j]+1)。初始化就把dp数组全初始化为1，因为本身也是一个子序列。这里有两层循环，先从前往后遍历整个nums数组，内层遍历就从前往后遍历到外层下标-1就行了。

代码如下：

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

时间复杂度：O(n^2)，空间复杂度：O(n)。

LeetCode 674. 最长连续递增序列

题目链接：LeetCode 674. 最长连续递增序列

思想：本题跟上题基本上情况都是一模一样的，除了子序列变成了连续连续，也就是说任何递增序列的元素在原数组必须要相邻。那么把上述循环中的if判断条件修改了就行，改为if(dp[j+1]>dp[j])然后再进行状态判断，如果不满足递增的话，dp[i]就等于1就行了，因为要重新进行计算。

代码如下：

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

时间复杂度：O(n^2)，空间复杂度：O(n)。

LeetCode 718. 最长重复子数组

题目链接：LeetCode 718. 最长重复子数组

思想：本题没有强调连续的话，子数组就相当于子序列。那么还是动归五部曲，第一个确定dp[i]。dp[i][j]是以下标i-1为结尾的A和下标j-1为结尾的B，最长重复子数组长度为dp[i][j]。第二个就是确定递推公式，dp[i][j]需要i-1和j-1的状态推导出来，那么当A[i-1]=B[j-1]的时候，dp[i][j] = dp[i-1][j-1]+1。初始化的话就把每一个初始化为0就行了，循环就外层遍历一个数组，内层遍历另一个数组就可以了。

代码如下：

    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 = 1; i <= nums1.size(); i++) {
            for (int j = 1; j <= nums2.size(); j++) {
                if (nums1[i-1] == nums2[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
                result = dp[i][j] > result ? dp[i][j] : result;
            }
        }
        return result;
    }

时间复杂度：O(n^2)，空间复杂度：O(n^2)。

LeetCode 1143. 最长公共子序列

题目链接：LeetCode 1143. 最长公共子序列

思想：其实本题跟上题是差不多的，主要差别就是递推公式上，相等的就是一样的递推公式，这里存在着不等，不等的话就看i-1和j-1状态上的数值谁大，谁大就取谁。即dp[i][j] = max(dp[i-1][j], dp[i][j-1]。

代码如下：

    int longestCommonSubsequence(string text1, string text2) {
        vector<vector<int>> dp(text1.size()+1, vector<int> (text2.size()+1, 0));
        int result = 0;
        for (int i = 1; i <= text1.size(); i++) {
            for (int j = 1; j <= text2.size(); 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]);
                result = dp[i][j] > result ? dp[i][j] : result;
            }
        }
        return result;
    }

时间复杂度：O(n^2)，空间复杂度：O(n^2)。

LeetCode 1035. 不相交的钱

题目链接：LeetCode 1035. 不相交的钱

思想：本题跟上题一模一样。遂不再重复。

代码如下：

    int maxUncrossedLines(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 = 1; i <= nums1.size(); i++) {
            for (int j = 1; j <= nums2.size(); 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]);
                result = dp[i][j] > result ? dp[i][j] : result;
            }
        }
        return result;
    }

时间复杂度：O(n^2)，空间复杂度：O(n^2)。

LeetCode 53. 最大子序和

题目链接：LeetCode 53. 最大子序和

思想：还是动归五部曲吧，第一步确定dp数组。这里dp[i]表示包括下标i的最大连续子序列和dp[i]。其次就是递推公式，dp[i]只有两个方向可以推出来：第一个状态当前nums[i]加入子序列即dp[i] = dp[i-1] + nums[i]；第二个状态是重新开始计算子序列即dp[i] = nums[i]。这俩个状态取最大就行了。初始化只需要初始化dp[0]就行了，dp[0]很明显要等于nums[0]。遍历顺序就直接从前往后遍历就行了。

代码如下：

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

时间复杂度：O(n)，空间复杂度：O(n)。

LeetCode 392. 判断子序列

题目链接：LeetCode 392. 判断子序列

思想：本题其实跟判断最长子序列是一个道理，只需最后判断得出的长度是否等于s的长度就行了。遂不再讲解了。

代码如下：

    bool isSubsequence(string s, string t) {
        if (s.size() > t.size()) return false;
        vector<vector<int>> dp(s.size()+1, vector<int> (t.size()+1, 0));
        for (int i = 1; i <= s.size(); i++) {
            for (int j = 1; j <= t.size(); j++) {
                if (s[i-1] == t[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
                else dp[i][j] = max(dp[i][j-1], dp[i-1][j]);
            }
        }
        if (dp[s.size()][t.size()] == s.size()) return true;
        return false;
    }

时间复杂度：O(n^2)，空间复杂度：O(n^2)。