代码随想录Day37-动态规划：力扣第188h、309m、714m、300m、674e、718m、1143m题

猪扒已出闸

已于 2023-10-09 15:15:13 修改

阅读量54

点赞数

分类专栏：代码随想录文章标签：动态规划 leetcode c++ 算法职场和发展

于 2023-10-08 17:49:07 首次发布

本文链接：https://blog.csdn.net/Jerome_zp/article/details/133274622

版权

代码随想录专栏收录该内容

43 篇文章 0 订阅

订阅专栏

188h. 买卖股票的最佳时机IV

题目链接
 代码随想录文章讲解链接

方法一：动态规划+滚动数组

用时：22m45s

思路

dp数组：dp[i][0]表示第i天没有买入过股票，dp[i][2j+1]表示第i天第j+1次持有股票，dp[i][2j]表示第i天第j+1次不持有股票
状态转移：状态转移跟123m题一样

时间复杂度： $\cdot k)$
空间复杂度： $O (k)$

C++代码

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        if (prices.size() == 0) return 0;
        vector<int> dp(2 * k + 1, 0);
        for (int j = 1; j < dp.size(); j += 2) dp[j] = -prices[0];
        for (int i = 1; i < prices.size(); ++i) {
            for (int j = dp.size() - 1; j >= 2; j -= 2) {
                dp[j] = max(dp[j], dp[j - 1] + prices[i]);  // 第i次不持有
                dp[j - 1] = max(dp[j - 1], dp[j - 2] - prices[i]);  // 第i次持有
            }
        }
        return dp[2 * k];
    }
};

看完讲解的思考

无。

代码实现遇到的问题

无。

309m. 最佳买卖股票时机含冷冻期

题目链接
 代码随想录文章讲解链接

方法一：动态规划

用时：25m59s

思路

dp数组：dp[i][0]表示第i天持有股票的收支，dp[i][1]表示第i天不持有股票且第i-1天也不持有股票的收支，dp[i][2]表示第i天不持有股票且第i-1持有股票的收支。
状态转移：

dp[i][0]：上一天持有股票，今天继续持有股票，以及前两天不持有股票，今天买入股票，两种情况中的最大值，上一天不持有股票，上上天持有股票的情况下，当天处于冻结期，无法买入股票。即dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i])
dp[i][1]：上一天不持有股票，今天继续保持不持有股票，上一天不持有股票有两种情况，所以值为两者中的最大值，即dp[i][1] = max(dp[i - 1][1], dp[i - 1][2])
dp[i][2]：上一天持有股票，今天卖出股票，即dp[i][2] = dp[i - 1][0] + prices[i]

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

C++代码

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int size = prices.size();
        vector<vector<int>> dp(size, vector<int>(3, 0));  // dp数组
        dp[0][0] = -prices[0];  // dp数组初始化
        for (int i = 1; i < size; ++i) {  // 状态转移
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][2]);
            dp[i][2] = dp[i - 1][0] + prices[i];
        }
        return max(dp[size - 1][1], dp[size - 1][2]);
    }
};

方法二：动态规划+滚动数组

用时：2m54s

思路

在方法一的基础上，dp数组使用一维数组。

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

C++代码

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int size = prices.size();
        vector<int> dp(3, 0);  // dp数组
        dp[0] = -prices[0];  // dp数组初始化
        for (int i = 1; i < size; ++i) {  // 状态转移
            int tmp = dp[0] + prices[i];
            dp[0] = max(dp[0], dp[1] - prices[i]);
            dp[1] = max(dp[1], dp[2]);
            dp[2] = tmp;
        }
        return max(dp[1], dp[2]);
    }
};

看完讲解的思考

无。

代码实现遇到的问题

无。

714m. 买卖股票的最佳时机含手续费

题目链接
 代码随想录文章讲解链接

方法一：动态规划

用时：4m11s

思路

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

C++代码

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int dp0 = -prices[0] - fee, dp1 = 0;
        for (int i = 1; i < prices.size(); ++i) {
            int tmp = max(dp0, dp1 - prices[i] - fee);
            dp1 = max(dp1, dp0 + prices[i]);
            dp0 = tmp;
        }
        return dp1;
    }
};

看完讲解的思考

无。

代码实现遇到的问题

无。

300m. 最长递增子序列

题目链接
 代码随想录文章讲解链接

方法一：动态规划

用时：16m37s

思路

对于第i个元素nums[i]，以nums[i]开头的最长严格递增子序列（LIS）的长度，等于1加上以nums[i]之后的大于nums[i]的元素为开头的LIS的最大长度，用一个数组记录以每个元素为开头的LIS的最大长度，由后往前遍历，因为前面的LIS长度依赖于后面的值。
得到全部LIS长度后，最大值即为答案。

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

C++代码

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

方法二：贪心+二分查找

用时：15m31s

思路

数组last：last[i]表示长度为i的子序列的最小末尾元素。
贪心思想：为了让子序列尽可能的长，所以子序列的末尾元素要尽可能的小

遍历数组，若当前元素n大于last数组最后一个元素，则递增子序列可以增长，并且n是作为末尾元素，所以将n添加到last数组末尾。若n小于last数组最后一个元素，则递增子序列无法增长，但是可以按照贪心思想更新last数组：找到大于n的第一个数，将其替换成n，由于last是递增数组，所以可以用二分查找。
最后的答案就是last数组的长度。

时间复杂度： $\log n)$ 。
空间复杂度： $O (n)$ 。

C++代码

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> last;
        last.push_back(nums[0]);
        
        for (int i = 1; i < nums.size(); ++i) {
            int target = nums[i];
            if (target > last.back()) last.push_back(target);
            else if (target < last.back()) {
            	// 二分查找
                int left = 0, right = last.size() - 1;
                while (left <= right) {
                    int mid = left + (right - left) / 2;
                    if (last[mid] < target) left = mid + 1;
                    else right = mid - 1;
                }
                last[left] = target;
            }
        }
        return last.size();
    }
};

看完讲解的思考

无。

代码实现遇到的问题

无。

674e. 最长连续递增序列

题目链接
 代码随想录文章讲解链接

方法一：滑动窗口

用时：7m26s

思路

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

C++代码

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

方法二：动态规划

用时：5m7s

思路

dp数组：dp[i]表示以nums[i]为结尾的连续递增子序列的最大长度。
状态转移：如果nums[i]大于nums[i-1]，则dp[i] = dp[i-1] + 1；否则dp[i] = 1。
最后答案是dp数组中的最大值。由于状态转移只与前一个状态有关，所以可以用一个变量记录前一个状态即可。

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

C++代码

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

看完讲解的思考

无。

代码实现遇到的问题

无。

718m. 最长重复子数组

题目链接
 代码随想录文章讲解链接

方法一：暴力解法

用时：21m15s

思路

逐个子数组遍历，逐个匹配。

时间复杂度： $O(n^3)$ 。
空间复杂度： $O (1)$ 。

C++代码

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        int idx1 = 0;
        int size1 = nums1.size(), size2 = nums2.size();
        int res = 0;

        while (idx1 < size1) {
            for (int i = 0; i < size2 - res; ++i) {
                if (nums2[i] == nums1[idx1]) {
                    int offset = 1;
                    if (res == 0) res = 1;
                    while (idx1 + offset < size1 && i + offset < size2 && nums1[idx1 + offset] == nums2[i + offset]) {
                        ++offset;
                        res = max(res, offset);
                    }
                }
            }
            ++idx1;
        }
        return res;
    }
};

方法二：动态规划

用时：5m52s

思路

dp数组：二维dp数组，dp[i][j]表示nums1中以nums1[i - 1]为结尾的子数组和nums2中以nums2[j - 1]为结尾的子数组的最长公共子数组的长度。
状态转移：若nums1[i - 1] == nums2[j - 1]，则dp[i][j] = dp[i - 1][j - 1] + 1。

时间复杂度： $O (mn)$ ，m为nums1的长度，n为nums2的长度。
空间复杂度： $O (mn)$ 。

C++代码

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

方法三：动态规划+滚动数组

用时：5m3s

思路

方法二空间可以用滚动数组优化。

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

C++代码

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

看完讲解的思考

无。

代码实现遇到的问题

无。

1143m. 最长公共子序列

题目链接
 代码随想录文章讲解链接

方法一：动态规划

用时：11m12s

思路

dp数组：二维dp数组，dp[i][j]表示text1[:i]和text2[:j]的最长公共子序列的长度。
状态转移：见代码。

时间复杂度： $O (mn)$ 。
空间复杂度： $O (mn)$ 。

C++代码

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