Skip to content

Commit ba74d51

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1671
No.1671.Minimum Number of Removals to Make Mountain Array
1 parent 70f47a9 commit ba74d51

File tree

6 files changed

+347
-2
lines changed

6 files changed

+347
-2
lines changed

‎solution/1600-1699/1671.Minimum Number of Removals to Make Mountain Array/README.md

Lines changed: 124 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -52,22 +52,145 @@
5252

5353
<!-- 这里可写通用的实现逻辑 -->
5454

55+
**方法一：动态规划**
56+
57+
本题可以转化为求最长上升子序列和最长下降子序列。
58+
59+
我们定义 $left[i]$ 表示以 $nums[i]$ 结尾的最长上升子序列的长度，定义 $right[i]$ 表示以 $nums[i]$ 开头的最长下降子序列的长度。
60+
61+
那么最终答案就是 $n - \max(left[i] + right[i] - 1)$，其中 $1 \leq i \leq n$，并且 $left[i] \gt 1$ 且 $right[i] \gt 1$。
62+
5563
<!-- tabs:start -->
5664

5765
### **Python3**
5866

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

6169
```python
62-
70+
class Solution:
71+
def minimumMountainRemovals(self, nums: List[int]) -> int:
72+
n = len(nums)
73+
left = [1] * n
74+
right = [1] * n
75+
for i in range(1, n):
76+
for j in range(i):
77+
if nums[i] > nums[j]:
78+
left[i] = max(left[i], left[j] + 1)
79+
for i in range(n - 2, -1, -1):
80+
for j in range(i + 1, n):
81+
if nums[i] > nums[j]:
82+
right[i] = max(right[i], right[j] + 1)
83+
return n - max(a + b - 1 for a, b in zip(left, right) if a > 1 and b > 1)
6384
```
6485

6586
### **Java**
6687

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

6990
```java
91+
class Solution {
92+
public int minimumMountainRemovals(int[] nums) {
93+
int n = nums.length;
94+
int[] left = new int[n];
95+
int[] right = new int[n];
96+
Arrays.fill(left, 1);
97+
Arrays.fill(right, 1);
98+
for (int i = 1; i < n; ++i) {
99+
for (int j = 0; j < i; ++j) {
100+
if (nums[i] > nums[j]) {
101+
left[i] = Math.max(left[i], left[j] + 1);
102+
}
103+
}
104+
}
105+
for (int i = n - 2; i >= 0; --i) {
106+
for (int j = i + 1; j < n; ++j) {
107+
if (nums[i] > nums[j]) {
108+
right[i] = Math.max(right[i], right[j] + 1);
109+
}
110+
}
111+
}
112+
int ans = 0;
113+
for (int i = 0; i < n; ++i) {
114+
if (left[i] > 1 && right[i] > 1) {
115+
ans = Math.max(ans, left[i] + right[i] - 1);
116+
}
117+
}
118+
return n - ans;
119+
}
120+
}
121+
```
122+
123+
### **C++**
124+
125+
```cpp
126+
class Solution {
127+
public:
128+
int minimumMountainRemovals(vector<int>& nums) {
129+
int n = nums.size();
130+
vector<int> left(n, 1), right(n, 1);
131+
for (int i = 1; i < n; ++i) {
132+
for (int j = 0; j < i; ++j) {
133+
if (nums[i] > nums[j]) {
134+
left[i] = max(left[i], left[j] + 1);
135+
}
136+
}
137+
}
138+
for (int i = n - 2; i >= 0; --i) {
139+
for (int j = i + 1; j < n; ++j) {
140+
if (nums[i] > nums[j]) {
141+
right[i] = max(right[i], right[j] + 1);
142+
}
143+
}
144+
}
145+
int ans = 0;
146+
for (int i = 0; i < n; ++i) {
147+
if (left[i] > 1 && right[i] > 1) {
148+
ans = max(ans, left[i] + right[i] - 1);
149+
}
150+
}
151+
return n - ans;
152+
}
153+
};
154+
```
70155
156+
### **Go**
157+
158+
```go
159+
func minimumMountainRemovals(nums []int) int {
160+
n := len(nums)
161+
left, right := make([]int, n), make([]int, n)
162+
for i := range left {
163+
left[i], right[i] = 1, 1
164+
}
165+
for i := 1; i < n; i++ {
166+
for j := 0; j < i; j++ {
167+
if nums[i] > nums[j] {
168+
left[i] = max(left[i], left[j]+1)
169+
}
170+
}
171+
}
172+
for i := n - 2; i >= 0; i-- {
173+
for j := i + 1; j < n; j++ {
174+
if nums[i] > nums[j] {
175+
right[i] = max(right[i], right[j]+1)
176+
}
177+
}
178+
}
179+
ans := 0
180+
for i := range left {
181+
if left[i] > 1 && right[i] > 1 {
182+
ans = max(ans, left[i]+right[i]-1)
183+
}
184+
}
185+
return n - ans
186+
}
187+
188+
func max(a, b int) int {
189+
if a > b {
190+
return a
191+
}
192+
return b
193+
}
71194
```
72195

73196
### **...**

‎solution/1600-1699/1671.Minimum Number of Removals to Make Mountain Array/README_EN.md

Lines changed: 116 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -51,13 +51,128 @@
5151
### **Python3**
5252

5353
```python
54-
54+
class Solution:
55+
def minimumMountainRemovals(self, nums: List[int]) -> int:
56+
n = len(nums)
57+
left = [1] * n
58+
right = [1] * n
59+
for i in range(1, n):
60+
for j in range(i):
61+
if nums[i] > nums[j]:
62+
left[i] = max(left[i], left[j] + 1)
63+
for i in range(n - 2, -1, -1):
64+
for j in range(i + 1, n):
65+
if nums[i] > nums[j]:
66+
right[i] = max(right[i], right[j] + 1)
67+
return n - max(a + b - 1 for a, b in zip(left, right) if a > 1 and b > 1)
5568
```
5669

5770
### **Java**
5871

5972
```java
73+
class Solution {
74+
public int minimumMountainRemovals(int[] nums) {
75+
int n = nums.length;
76+
int[] left = new int[n];
77+
int[] right = new int[n];
78+
Arrays.fill(left, 1);
79+
Arrays.fill(right, 1);
80+
for (int i = 1; i < n; ++i) {
81+
for (int j = 0; j < i; ++j) {
82+
if (nums[i] > nums[j]) {
83+
left[i] = Math.max(left[i], left[j] + 1);
84+
}
85+
}
86+
}
87+
for (int i = n - 2; i >= 0; --i) {
88+
for (int j = i + 1; j < n; ++j) {
89+
if (nums[i] > nums[j]) {
90+
right[i] = Math.max(right[i], right[j] + 1);
91+
}
92+
}
93+
}
94+
int ans = 0;
95+
for (int i = 0; i < n; ++i) {
96+
if (left[i] > 1 && right[i] > 1) {
97+
ans = Math.max(ans, left[i] + right[i] - 1);
98+
}
99+
}
100+
return n - ans;
101+
}
102+
}
103+
```
104+
105+
### **C++**
106+
107+
```cpp
108+
class Solution {
109+
public:
110+
int minimumMountainRemovals(vector<int>& nums) {
111+
int n = nums.size();
112+
vector<int> left(n, 1), right(n, 1);
113+
for (int i = 1; i < n; ++i) {
114+
for (int j = 0; j < i; ++j) {
115+
if (nums[i] > nums[j]) {
116+
left[i] = max(left[i], left[j] + 1);
117+
}
118+
}
119+
}
120+
for (int i = n - 2; i >= 0; --i) {
121+
for (int j = i + 1; j < n; ++j) {
122+
if (nums[i] > nums[j]) {
123+
right[i] = max(right[i], right[j] + 1);
124+
}
125+
}
126+
}
127+
int ans = 0;
128+
for (int i = 0; i < n; ++i) {
129+
if (left[i] > 1 && right[i] > 1) {
130+
ans = max(ans, left[i] + right[i] - 1);
131+
}
132+
}
133+
return n - ans;
134+
}
135+
};
136+
```
60137
138+
### **Go**
139+
140+
```go
141+
func minimumMountainRemovals(nums []int) int {
142+
n := len(nums)
143+
left, right := make([]int, n), make([]int, n)
144+
for i := range left {
145+
left[i], right[i] = 1, 1
146+
}
147+
for i := 1; i < n; i++ {
148+
for j := 0; j < i; j++ {
149+
if nums[i] > nums[j] {
150+
left[i] = max(left[i], left[j]+1)
151+
}
152+
}
153+
}
154+
for i := n - 2; i >= 0; i-- {
155+
for j := i + 1; j < n; j++ {
156+
if nums[i] > nums[j] {
157+
right[i] = max(right[i], right[j]+1)
158+
}
159+
}
160+
}
161+
ans := 0
162+
for i := range left {
163+
if left[i] > 1 && right[i] > 1 {
164+
ans = max(ans, left[i]+right[i]-1)
165+
}
166+
}
167+
return n - ans
168+
}
169+
170+
func max(a, b int) int {
171+
if a > b {
172+
return a
173+
}
174+
return b
175+
}
61176
```
62177

63178
### **...**

‎solution/1600-1699/1671.Minimum Number of Removals to Make Mountain Array/Solution.cpp

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
class Solution {
2+
public:
3+
int minimumMountainRemovals(vector<int>& nums) {
4+
int n = nums.size();
5+
vector<int> left(n, 1), right(n, 1);
6+
for (int i = 1; i < n; ++i) {
7+
for (int j = 0; j < i; ++j) {
8+
if (nums[i] > nums[j]) {
9+
left[i] = max(left[i], left[j] + 1);
10+
}
11+
}
12+
}
13+
for (int i = n - 2; i >= 0; --i) {
14+
for (int j = i + 1; j < n; ++j) {
15+
if (nums[i] > nums[j]) {
16+
right[i] = max(right[i], right[j] + 1);
17+
}
18+
}
19+
}
20+
int ans = 0;
21+
for (int i = 0; i < n; ++i) {
22+
if (left[i] > 1 && right[i] > 1) {
23+
ans = max(ans, left[i] + right[i] - 1);
24+
}
25+
}
26+
return n - ans;
27+
}
28+
};

‎solution/1600-1699/1671.Minimum Number of Removals to Make Mountain Array/Solution.go

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

‎solution/1600-1699/1671.Minimum Number of Removals to Make Mountain Array/Solution.java

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
class Solution {
2+
public int minimumMountainRemovals(int[] nums) {
3+
int n = nums.length;
4+
int[] left = new int[n];
5+
int[] right = new int[n];
6+
Arrays.fill(left, 1);
7+
Arrays.fill(right, 1);
8+
for (int i = 1; i < n; ++i) {
9+
for (int j = 0; j < i; ++j) {
10+
if (nums[i] > nums[j]) {
11+
left[i] = Math.max(left[i], left[j] + 1);
12+
}
13+
}
14+
}
15+
for (int i = n - 2; i >= 0; --i) {
16+
for (int j = i + 1; j < n; ++j) {
17+
if (nums[i] > nums[j]) {
18+
right[i] = Math.max(right[i], right[j] + 1);
19+
}
20+
}
21+
}
22+
int ans = 0;
23+
for (int i = 0; i < n; ++i) {
24+
if (left[i] > 1 && right[i] > 1) {
25+
ans = Math.max(ans, left[i] + right[i] - 1);
26+
}
27+
}
28+
return n - ans;
29+
}
30+
}

‎solution/1600-1699/1671.Minimum Number of Removals to Make Mountain Array/Solution.py

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
class Solution:
2+
def minimumMountainRemovals(self, nums: List[int]) -> int:
3+
n = len(nums)
4+
left = [1] * n
5+
right = [1] * n
6+
for i in range(1, n):
7+
for j in range(i):
8+
if nums[i] > nums[j]:
9+
left[i] = max(left[i], left[j] + 1)
10+
for i in range(n - 2, -1, -1):
11+
for j in range(i + 1, n):
12+
if nums[i] > nums[j]:
13+
right[i] = max(right[i], right[j] + 1)
14+
return n - max(a + b - 1 for a, b in zip(left, right) if a > 1 and b > 1)

0 commit comments

Comments
 (0)