feat: add solutions to lc problem: No.2907 (doocs#1847)

No.2907.Maximum Profitable Triplets With Increasing Prices I

Author: yanglbme

solution/2900-2999/2907.Maximum Profitable Triplets With Increasing Prices I/README.md

@@ -0,0 +1,249 @@
+# [2907. Maximum Profitable Triplets With Increasing Prices I](https://leetcode.cn/problems/maximum-profitable-triplets-with-increasing-prices-i)
+
+[English Version](/solution/2900-2999/2907.Maximum%20Profitable%20Triplets%20With%20Increasing%20Prices%20I/README_EN.md)
+
+## 题目描述
+
+<!-- 这里写题目描述 -->
+
+<p>Given the <strong>0-indexed</strong> arrays <code>prices</code> and <code>profits</code> of length <code>n</code>. There are <code>n</code> items in an store where the <code>i<sup>th</sup></code> item has a price of <code>prices[i]</code> and a profit of <code>profits[i]</code>.</p>
+
+<p>We have to pick three items with the following condition:</p>
+
+<ul>
+	<li><code>prices[i] &lt; prices[j] &lt; prices[k]</code> where <code>i &lt; j &lt; k</code>.</li>
+</ul>
+
+<p>If we pick items with indices <code>i</code>, <code>j</code> and <code>k</code> satisfying the above condition, the profit would be <code>profits[i] + profits[j] + profits[k]</code>.</p>
+
+<p>Return<em> the <strong>maximum profit</strong> we can get, and </em><code>-1</code><em> if it&#39;s not possible to pick three items with the given condition.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> prices = [10,2,3,4], profits = [100,2,7,10]
+<strong>Output:</strong> 19
+<strong>Explanation:</strong> We can&#39;t pick the item with index i=0 since there are no indices j and k such that the condition holds.
+So the only triplet we can pick, are the items with indices 1, 2 and 3 and it&#39;s a valid pick since prices[1] &lt; prices[2] &lt; prices[3].
+The answer would be sum of their profits which is 2 + 7 + 10 = 19.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> prices = [1,2,3,4,5], profits = [1,5,3,4,6]
+<strong>Output:</strong> 15
+<strong>Explanation:</strong> We can select any triplet of items since for each triplet of indices i, j and k such that i &lt; j &lt; k, the condition holds.
+Therefore the maximum profit we can get would be the 3 most profitable items which are indices 1, 3 and 4.
+The answer would be sum of their profits which is 5 + 4 + 6 = 15.</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> prices = [4,3,2,1], profits = [33,20,19,87]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> We can&#39;t select any triplet of indices such that the condition holds, so we return -1.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>3 &lt;= prices.length == profits.length &lt;= 2000</code></li>
+	<li><code>1 &lt;= prices[i] &lt;= 10<sup>6</sup></code></li>
+	<li><code>1 &lt;= profits[i] &lt;= 10<sup>6</sup></code></li>
+</ul>
+
+## 解法
+
+<!-- 这里可写通用的实现逻辑 -->
+
+**方法一：枚举中间元素**
+
+我们可以枚举中间元素 $profits[j]$，然后再枚举左边元素 $profits[i]$ 和右边元素 $profits[k]$。对于每个 $profits[j]$，我们需要找到最大的 $profits[i]$ 和最大的 $profits[k]$，使得 $prices[i] < prices[j] < prices[k]$。我们记 $left$ 为 $profits[j]$ 左边的最大值，而 $right$ 为 $profits[j]$ 右边的最大值。如果存在，那么我们更新答案为 $ans = \max(ans, left + profits[j] + right)$。
+
+时间复杂度 $O(n^2)$，其中 $n$ 为数组长度。空间复杂度 $O(1)$。
+
+<!-- tabs:start -->
+
+### **Python3**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```python
+class Solution:
+    def maxProfit(self, prices: List[int], profits: List[int]) -> int:
+        n = len(prices)
+        ans = -1
+        for j, x in enumerate(profits):
+            left = right = 0
+            for i in range(j):
+                if prices[i] < prices[j] and left < profits[i]:
+                    left = profits[i]
+            for k in range(j + 1, n):
+                if prices[j] < prices[k] and right < profits[k]:
+                    right = profits[k]
+            if left and right:
+                ans = max(ans, left + x + right)
+        return ans
+```
+
+### **Java**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```java
+class Solution {
+    public int maxProfit(int[] prices, int[] profits) {
+        int n = prices.length;
+        int ans = -1;
+        for (int j = 0; j < n; ++j) {
+            int left = 0, right = 0;
+            for (int i = 0; i < j; ++i) {
+                if (prices[i] < prices[j]) {
+                    left = Math.max(left, profits[i]);
+                }
+            }
+            for (int k = j + 1; k < n; ++k) {
+                if (prices[j] < prices[k]) {
+                    right = Math.max(right, profits[k]);
+                }
+            }
+            if (left > 0 && right > 0) {
+                ans = Math.max(ans, left + profits[j] + right);
+            }
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int maxProfit(vector<int>& prices, vector<int>& profits) {
+        int n = prices.size();
+        int ans = -1;
+        for (int j = 0; j < n; ++j) {
+            int left = 0, right = 0;
+            for (int i = 0; i < j; ++i) {
+                if (prices[i] < prices[j]) {
+                    left = max(left, profits[i]);
+                }
+            }
+            for (int k = j + 1; k < n; ++k) {
+                if (prices[j] < prices[k]) {
+                    right = max(right, profits[k]);
+                }
+            }
+            if (left && right) {
+                ans = max(ans, left + profits[j] + right);
+            }
+        }
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func maxProfit(prices []int, profits []int) int {
+	n := len(prices)
+	ans := -1
+	for j, x := range profits {
+		left, right := 0, 0
+		for i := 0; i < j; i++ {
+			if prices[i] < prices[j] {
+				left = max(left, profits[i])
+			}
+		}
+		for k := j + 1; k < n; k++ {
+			if prices[j] < prices[k] {
+				right = max(right, profits[k])
+			}
+		}
+		if left > 0 && right > 0 {
+			ans = max(ans, left+x+right)
+		}
+	}
+	return ans
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+```
+
+### **TypeScript**
+
+```ts
+function maxProfit(prices: number[], profits: number[]): number {
+    const n = prices.length;
+    let ans = -1;
+    for (let j = 0; j < n; ++j) {
+        let [left, right] = [0, 0];
+        for (let i = 0; i < j; ++i) {
+            if (prices[i] < prices[j]) {
+                left = Math.max(left, profits[i]);
+            }
+        }
+        for (let k = j + 1; k < n; ++k) {
+            if (prices[j] < prices[k]) {
+                right = Math.max(right, profits[k]);
+            }
+        }
+        if (left > 0 && right > 0) {
+            ans = Math.max(ans, left + profits[j] + right);
+        }
+    }
+    return ans;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn max_profit(prices: Vec<i32>, profits: Vec<i32>) -> i32 {
+        let n = prices.len();
+        let mut ans = -1;
+
+        for j in 0..n {
+            let mut left = 0;
+            let mut right = 0;
+
+            for i in 0..j {
+                if prices[i] < prices[j] {
+                    left = left.max(profits[i]);
+                }
+            }
+
+            for k in (j + 1)..n {
+                if prices[j] < prices[k] {
+                    right = right.max(profits[k]);
+                }
+            }
+
+            if left > 0 && right > 0 {
+                ans = ans.max(left + profits[j] + right);
+            }
+        }
+
+        ans
+    }
+}
+```
+
+### **...**
+
+```
+
+```
+
+<!-- tabs:end -->