Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Skip to content

Commit ca80e6d

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problems: No.2908,2909 (doocs#1864)
1 parent e008b9f commit ca80e6d

File tree

14 files changed

+614
-12
lines changed

14 files changed

+614
-12
lines changed

‎solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/README.md

Lines changed: 107 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -62,34 +62,138 @@
6262

6363
<!-- 这里可写通用的实现逻辑 -->
6464

65+
**方法一：预处理 + 枚举**
66+
67+
我们可以预处理出每个位置右侧的最小值，记录在数组 $right[i]$ 中，即 $right[i]$ 表示 $nums[i+1..n-1]$ 中的最小值。
68+
69+
接下来，我们从左到右枚举山形三元组的中间元素 $nums[i]$，用一个变量 $left$ 表示 $nums[0..i-1]$ 中的最小值，用一个变量 $ans$ 表示当前找到的最小元素和。对于每个 $i$，我们需要找到满足 $left < nums[i]$ 且 $right[i+1] < nums[i]$ 的元素 $nums[i]$，并更新 $ans$。
70+
71+
最后，如果 $ans$ 仍然为初始值，则说明不存在山形三元组，返回 $-1$。
72+
73+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组长度。
74+
6575
<!-- tabs:start -->
6676

6777
### **Python3**
6878

6979
<!-- 这里可写当前语言的特殊实现逻辑 -->
7080

7181
```python
72-
82+
class Solution:
83+
def minimumSum(self, nums: List[int]) -> int:
84+
n = len(nums)
85+
right = [inf] * (n + 1)
86+
for i in range(n - 1, -1, -1):
87+
right[i] = min(right[i + 1], nums[i])
88+
ans = left = inf
89+
for i, x in enumerate(nums):
90+
if left < x and right[i + 1] < x:
91+
ans = min(ans, left + x + right[i + 1])
92+
left = min(left, x)
93+
return -1 if ans == inf else ans
7394
```
7495

7596
### **Java**
7697

7798
<!-- 这里可写当前语言的特殊实现逻辑 -->
7899

79100
```java
80-
101+
class Solution {
102+
public int minimumSum(int[] nums) {
103+
int n = nums.length;
104+
int[] right = new int[n + 1];
105+
final int inf = 1 << 30;
106+
right[n] = inf;
107+
for (int i = n - 1; i >= 0; --i) {
108+
right[i] = Math.min(right[i + 1], nums[i]);
109+
}
110+
int ans = inf, left = inf;
111+
for (int i = 0; i < n; ++i) {
112+
if (left < nums[i] && right[i + 1] < nums[i]) {
113+
ans = Math.min(ans, left + nums[i] + right[i + 1]);
114+
}
115+
left = Math.min(left, nums[i]);
116+
}
117+
return ans == inf ? -1 : ans;
118+
}
119+
}
81120
```
82121

83122
### **C++**
84123

85124
```cpp
86-
125+
class Solution {
126+
public:
127+
int minimumSum(vector<int>& nums) {
128+
int n = nums.size();
129+
const int inf = 1 << 30;
130+
int right[n + 1];
131+
right[n] = inf;
132+
for (int i = n - 1; ~i; --i) {
133+
right[i] = min(right[i + 1], nums[i]);
134+
}
135+
int ans = inf, left = inf;
136+
for (int i = 0; i < n; ++i) {
137+
if (left < nums[i] && right[i + 1] < nums[i]) {
138+
ans = min(ans, left + nums[i] + right[i + 1]);
139+
}
140+
left = min(left, nums[i]);
141+
}
142+
return ans == inf ? -1 : ans;
143+
}
144+
};
87145
```
88146
89147
### **Go**
90148
91149
```go
150+
func minimumSum(nums []int) int {
151+
n := len(nums)
152+
const inf = 1 << 30
153+
right := make([]int, n+1)
154+
right[n] = inf
155+
for i := n - 1; i >= 0; i-- {
156+
right[i] = min(right[i+1], nums[i])
157+
}
158+
ans, left := inf, inf
159+
for i, x := range nums {
160+
if left < x && right[i+1] < x {
161+
ans = min(ans, left+x+right[i+1])
162+
}
163+
left = min(left, x)
164+
}
165+
if ans == inf {
166+
return -1
167+
}
168+
return ans
169+
}
170+
171+
func min(a, b int) int {
172+
if a < b {
173+
return a
174+
}
175+
return b
176+
}
177+
```
92178

179+
### **TypeScript**
180+
181+
```ts
182+
function minimumSum(nums: number[]): number {
183+
const n = nums.length;
184+
const right: number[] = Array(n + 1).fill(Infinity);
185+
for (let i = n - 1; ~i; --i) {
186+
right[i] = Math.min(right[i + 1], nums[i]);
187+
}
188+
let [ans, left] = [Infinity, Infinity];
189+
for (let i = 0; i < n; ++i) {
190+
if (left < nums[i] && right[i + 1] < nums[i]) {
191+
ans = Math.min(ans, left + nums[i] + right[i + 1]);
192+
}
193+
left = Math.min(left, nums[i]);
194+
}
195+
return ans === Infinity ? -1 : ans;
196+
}
93197
```
94198

95199
### **...**

‎solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/README_EN.md

Lines changed: 107 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -56,30 +56,134 @@ And the sum of this triplet is nums[1] + nums[3] + nums[5] = 13. It can be shown
5656

5757
## Solutions
5858

59+
**Solution 1: Preprocessing + Enumeration**
60+
61+
We can preprocess the minimum value on the right side of each position and record it in the array $right[i]$, where $right[i]$ represents the minimum value in $nums[i+1..n-1]$.
62+
63+
Next, we enumerate the middle element $nums[i]$ of the mountain triplet from left to right, and use a variable $left$ to represent the minimum value in $ums[0..i-1]$, and a variable $ans$ to represent the current minimum element sum found. For each $i$, we need to find the element $nums[i]$ that satisfies $left < nums[i]$ and $right[i+1] < nums[i]$, and update $ans$.
64+
65+
Finally, if $ans$ is still the initial value, it means that there is no mountain triplet, and we return $-1$.
66+
67+
The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array.
68+
5969
<!-- tabs:start -->
6070

6171
### **Python3**
6272

6373
```python
64-
74+
class Solution:
75+
def minimumSum(self, nums: List[int]) -> int:
76+
n = len(nums)
77+
right = [inf] * (n + 1)
78+
for i in range(n - 1, -1, -1):
79+
right[i] = min(right[i + 1], nums[i])
80+
ans = left = inf
81+
for i, x in enumerate(nums):
82+
if left < x and right[i + 1] < x:
83+
ans = min(ans, left + x + right[i + 1])
84+
left = min(left, x)
85+
return -1 if ans == inf else ans
6586
```
6687

6788
### **Java**
6889

6990
```java
70-
91+
class Solution {
92+
public int minimumSum(int[] nums) {
93+
int n = nums.length;
94+
int[] right = new int[n + 1];
95+
final int inf = 1 << 30;
96+
right[n] = inf;
97+
for (int i = n - 1; i >= 0; --i) {
98+
right[i] = Math.min(right[i + 1], nums[i]);
99+
}
100+
int ans = inf, left = inf;
101+
for (int i = 0; i < n; ++i) {
102+
if (left < nums[i] && right[i + 1] < nums[i]) {
103+
ans = Math.min(ans, left + nums[i] + right[i + 1]);
104+
}
105+
left = Math.min(left, nums[i]);
106+
}
107+
return ans == inf ? -1 : ans;
108+
}
109+
}
71110
```
72111

73112
### **C++**
74113

75114
```cpp
76-
115+
class Solution {
116+
public:
117+
int minimumSum(vector<int>& nums) {
118+
int n = nums.size();
119+
const int inf = 1 << 30;
120+
int right[n + 1];
121+
right[n] = inf;
122+
for (int i = n - 1; ~i; --i) {
123+
right[i] = min(right[i + 1], nums[i]);
124+
}
125+
int ans = inf, left = inf;
126+
for (int i = 0; i < n; ++i) {
127+
if (left < nums[i] && right[i + 1] < nums[i]) {
128+
ans = min(ans, left + nums[i] + right[i + 1]);
129+
}
130+
left = min(left, nums[i]);
131+
}
132+
return ans == inf ? -1 : ans;
133+
}
134+
};
77135
```
78136
79137
### **Go**
80138
81139
```go
140+
func minimumSum(nums []int) int {
141+
n := len(nums)
142+
const inf = 1 << 30
143+
right := make([]int, n+1)
144+
right[n] = inf
145+
for i := n - 1; i >= 0; i-- {
146+
right[i] = min(right[i+1], nums[i])
147+
}
148+
ans, left := inf, inf
149+
for i, x := range nums {
150+
if left < x && right[i+1] < x {
151+
ans = min(ans, left+x+right[i+1])
152+
}
153+
left = min(left, x)
154+
}
155+
if ans == inf {
156+
return -1
157+
}
158+
return ans
159+
}
160+
161+
func min(a, b int) int {
162+
if a < b {
163+
return a
164+
}
165+
return b
166+
}
167+
```
82168

169+
### **TypeScript**
170+
171+
```ts
172+
function minimumSum(nums: number[]): number {
173+
const n = nums.length;
174+
const right: number[] = Array(n + 1).fill(Infinity);
175+
for (let i = n - 1; ~i; --i) {
176+
right[i] = Math.min(right[i + 1], nums[i]);
177+
}
178+
let [ans, left] = [Infinity, Infinity];
179+
for (let i = 0; i < n; ++i) {
180+
if (left < nums[i] && right[i + 1] < nums[i]) {
181+
ans = Math.min(ans, left + nums[i] + right[i + 1]);
182+
}
183+
left = Math.min(left, nums[i]);
184+
}
185+
return ans === Infinity ? -1 : ans;
186+
}
83187
```
84188

85189
### **...**

‎solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.cpp

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
class Solution {
2+
public:
3+
int minimumSum(vector<int>& nums) {
4+
int n = nums.size();
5+
const int inf = 1 << 30;
6+
int right[n + 1];
7+
right[n] = inf;
8+
for (int i = n - 1; ~i; --i) {
9+
right[i] = min(right[i + 1], nums[i]);
10+
}
11+
int ans = inf, left = inf;
12+
for (int i = 0; i < n; ++i) {
13+
if (left < nums[i] && right[i + 1] < nums[i]) {
14+
ans = min(ans, left + nums[i] + right[i + 1]);
15+
}
16+
left = min(left, nums[i]);
17+
}
18+
return ans == inf ? -1 : ans;
19+
}
20+
};

‎solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.go

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
func minimumSum(nums []int) int {
2+
n := len(nums)
3+
const inf = 1 << 30
4+
right := make([]int, n+1)
5+
right[n] = inf
6+
for i := n - 1; i >= 0; i-- {
7+
right[i] = min(right[i+1], nums[i])
8+
}
9+
ans, left := inf, inf
10+
for i, x := range nums {
11+
if left < x && right[i+1] < x {
12+
ans = min(ans, left+x+right[i+1])
13+
}
14+
left = min(left, x)
15+
}
16+
if ans == inf {
17+
return -1
18+
}
19+
return ans
20+
}
21+
22+
func min(a, b int) int {
23+
if a < b {
24+
return a
25+
}
26+
return b
27+
}

‎solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.java

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
class Solution {
2+
public int minimumSum(int[] nums) {
3+
int n = nums.length;
4+
int[] right = new int[n + 1];
5+
final int inf = 1 << 30;
6+
right[n] = inf;
7+
for (int i = n - 1; i >= 0; --i) {
8+
right[i] = Math.min(right[i + 1], nums[i]);
9+
}
10+
int ans = inf, left = inf;
11+
for (int i = 0; i < n; ++i) {
12+
if (left < nums[i] && right[i + 1] < nums[i]) {
13+
ans = Math.min(ans, left + nums[i] + right[i + 1]);
14+
}
15+
left = Math.min(left, nums[i]);
16+
}
17+
return ans == inf ? -1 : ans;
18+
}
19+
}

‎solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.py

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
class Solution:
2+
def minimumSum(self, nums: List[int]) -> int:
3+
n = len(nums)
4+
right = [inf] * (n + 1)
5+
for i in range(n - 1, -1, -1):
6+
right[i] = min(right[i + 1], nums[i])
7+
ans = left = inf
8+
for i, x in enumerate(nums):
9+
if left < x and right[i + 1] < x:
10+
ans = min(ans, left + x + right[i + 1])
11+
left = min(left, x)
12+
return -1 if ans == inf else ans

‎solution/2900-2999/2908.Minimum Sum of Mountain Triplets I/Solution.ts

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
function minimumSum(nums: number[]): number {
2+
const n = nums.length;
3+
const right: number[] = Array(n + 1).fill(Infinity);
4+
for (let i = n - 1; ~i; --i) {
5+
right[i] = Math.min(right[i + 1], nums[i]);
6+
}
7+
let [ans, left] = [Infinity, Infinity];
8+
for (let i = 0; i < n; ++i) {
9+
if (left < nums[i] && right[i + 1] < nums[i]) {
10+
ans = Math.min(ans, left + nums[i] + right[i + 1]);
11+
}
12+
left = Math.min(left, nums[i]);
13+
}
14+
return ans === Infinity ? -1 : ans;
15+
}

0 commit comments

Comments
 (0)