+ problem 188

Author: fruit-in

Problemset/0188-Best Time to Buy and Sell Stock IV/README.md

@@ -0,0 +1,54 @@
+# 188. Best Time to Buy and Sell Stock IV
+You are given an integer array `prices` where `prices[i]` is the price of a given stock on the <code>i<sup>th</sup></code> day, and an integer `k`.
+
+Find the maximum profit you can achieve. You may complete at most k transactions: i.e. you may buy at most `k` times and sell at most `k` times.
+
+**Note:** You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).
+
+#### Example 1:
+<pre>
+<strong>Input:</strong> k = 2, prices = [2,4,1]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> Buy on day 1 (price = 2) and sell on day 2 (price = 4), profit = 4-2 = 2.
+</pre>
+
+#### Example 2:
+<pre>
+<strong>Input:</strong> k = 2, prices = [3,2,6,5,0,3]
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> Buy on day 2 (price = 2) and sell on day 3 (price = 6), profit = 6-2 = 4. Then buy on day 5 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
+</pre>
+
+#### Constraints:
+* `1 <= k <= 100`
+* `1 <= prices.length <= 1000`
+* `0 <= prices[i] <= 1000`
+
+## Solutions (Rust)
+
+### 1. Solution
+```Rust
+impl Solution {
+    pub fn max_profit(k: i32, prices: Vec<i32>) -> i32 {
+        let k = k as usize;
+        let mut dp = vec![[0, i32::MIN]; k + 1];
+        let mut ret = 0;
+
+        for i in 0..prices.len() {
+            let mut tmp = dp.clone();
+
+            for j in 0..=i.min(k) {
+                if j < k {
+                    tmp[j + 1][1] = tmp[j + 1][1].max(dp[j][0] - prices[i]);
+                }
+                tmp[j][0] = tmp[j][0].max(dp[j][1] + prices[i]);
+                ret = ret.max(tmp[j][0]);
+            }
+
+            dp = tmp;
+        }
+
+        ret
+    }
+}
+```

Problemset/0188-Best Time to Buy and Sell Stock IV/README_CN.md

@@ -0,0 +1,55 @@
+# 188. 买卖股票的最佳时机 IV
+给你一个整数数组 `prices` 和一个整数 `k` ，其中 `prices[i]` 是某支给定的股票在第 `i` 天的价格。
+
+设计一个算法来计算你所能获取的最大利润。你最多可以完成 `k` 笔交易。也就是说，你最多可以买 `k` 次，卖 `k` 次。
+
+**注意：**你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
+
+#### 示例 1:
+<pre>
+<strong>输入:</strong> k = 2, prices = [2,4,1]
+<strong>输出:</strong> 2
+<strong>解释:</strong> 在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。
+</pre>
+
+#### 示例 2:
+<pre>
+<strong>输入:</strong> k = 2, prices = [3,2,6,5,0,3]
+<strong>输出:</strong> 7
+<strong>解释:</strong> 在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
+     随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。
+</pre>
+
+#### 提示:
+* `1 <= k <= 100`
+* `1 <= prices.length <= 1000`
+* `0 <= prices[i] <= 1000`
+
+## 题解 (Rust)
+
+### 1. 题解
+```Rust
+impl Solution {
+    pub fn max_profit(k: i32, prices: Vec<i32>) -> i32 {
+        let k = k as usize;
+        let mut dp = vec![[0, i32::MIN]; k + 1];
+        let mut ret = 0;
+
+        for i in 0..prices.len() {
+            let mut tmp = dp.clone();
+
+            for j in 0..=i.min(k) {
+                if j < k {
+                    tmp[j + 1][1] = tmp[j + 1][1].max(dp[j][0] - prices[i]);
+                }
+                tmp[j][0] = tmp[j][0].max(dp[j][1] + prices[i]);
+                ret = ret.max(tmp[j][0]);
+            }
+
+            dp = tmp;
+        }
+
+        ret
+    }
+}
+```

Problemset/0188-Best Time to Buy and Sell Stock IV/Solution.rs

@@ -0,0 +1,23 @@
+impl Solution {
+    pub fn max_profit(k: i32, prices: Vec<i32>) -> i32 {
+        let k = k as usize;
+        let mut dp = vec![[0, i32::MIN]; k + 1];
+        let mut ret = 0;
+
+        for i in 0..prices.len() {
+            let mut tmp = dp.clone();
+
+            for j in 0..=i.min(k) {
+                if j < k {
+                    tmp[j + 1][1] = tmp[j + 1][1].max(dp[j][0] - prices[i]);
+                }
+                tmp[j][0] = tmp[j][0].max(dp[j][1] + prices[i]);
+                ret = ret.max(tmp[j][0]);
+            }
+
+            dp = tmp;
+        }
+
+        ret
+    }
+}

README.md

@@ -152,6 +152,7 @@
 [173][173l]  |[Binary Search Tree Iterator][173]                                                    |![py]
 [179][179l]  |[Largest Number][179]                                                                 |![rs]
 [187][187l]  |[Repeated DNA Sequences][187]                                                         |![rb]  ![rs]
+[188][188l]  |[Best Time to Buy and Sell Stock IV][188]                                             |![rs]
 [189][189l]  |[Rotate Array][189]                                                                   |![rs]
 [190][190l]  |[Reverse Bits][190]                                                                   |![py]
 [191][191l]  |[Number of 1 Bits][191]                                                               |![rs]
@@ -1739,6 +1740,7 @@
 [173]:Problemset/0173-Binary%20Search%20Tree%20Iterator/README.md#173-binary-search-tree-iterator
 [179]:Problemset/0179-Largest%20Number/README.md#179-largest-number
 [187]:Problemset/0187-Repeated%20DNA%20Sequences/README.md#187-repeated-dna-sequences
+[188]:Problemset/0188-Best%20Time%20to%20Buy%20and%20Sell%20Stock%20IV/README.md#188-best-time-to-buy-and-sell-stock-iv
 [189]:Problemset/0189-Rotate%20Array/README.md#189-rotate-array
 [190]:Problemset/0190-Reverse%20Bits/README.md#190-reverse-bits
 [191]:Problemset/0191-Number%20of%201%20Bits/README.md#191-number-of-1-bits
@@ -3319,6 +3321,7 @@
 [173l]:https://leetcode.com/problems/binary-search-tree-iterator/
 [179l]:https://leetcode.com/problems/largest-number/
 [187l]:https://leetcode.com/problems/repeated-dna-sequences/
+[188l]:https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/
 [189l]:https://leetcode.com/problems/rotate-array/
 [190l]:https://leetcode.com/problems/reverse-bits/
 [191l]:https://leetcode.com/problems/number-of-1-bits/

README_CN.md

@@ -152,6 +152,7 @@
 [173][173l]  |[二叉搜索树迭代器][173]                                   |![py]
 [179][179l]  |[最大数][179]                                             |![rs]
 [187][187l]  |[重复的DNA序列][187]                                      |![rb]  ![rs]
+[188][188l]  |[买卖股票的最佳时机 IV][188]                              |![rs]
 [189][189l]  |[旋转数组][189]                                           |![rs]
 [190][190l]  |[颠倒二进制位][190]                                       |![py]
 [191][191l]  |[位1的个数][191]                                          |![rs]
@@ -1739,6 +1740,7 @@
 [173]:Problemset/0173-Binary%20Search%20Tree%20Iterator/README_CN.md#173-二叉搜索树迭代器
 [179]:Problemset/0179-Largest%20Number/README_CN.md#179-最大数
 [187]:Problemset/0187-Repeated%20DNA%20Sequences/README_CN.md#187-重复的dna序列
+[188]:Problemset/0188-Best%20Time%20to%20Buy%20and%20Sell%20Stock%20IV/README_CN.md#188-买卖股票的最佳时机-iv
 [189]:Problemset/0189-Rotate%20Array/README_CN.md#189-旋转数组
 [190]:Problemset/0190-Reverse%20Bits/README_CN.md#190-颠倒二进制位
 [191]:Problemset/0191-Number%20of%201%20Bits/README_CN.md#191-位1的个数
@@ -3319,6 +3321,7 @@
 [173l]:https://leetcode.cn/problems/binary-search-tree-iterator/
 [179l]:https://leetcode.cn/problems/largest-number/
 [187l]:https://leetcode.cn/problems/repeated-dna-sequences/
+[188l]:https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iv/
 [189l]:https://leetcode.cn/problems/rotate-array/
 [190l]:https://leetcode.cn/problems/reverse-bits/
 [191l]:https://leetcode.cn/problems/number-of-1-bits/