Skip to content

Commit 5cd6890

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.2263
No.2263.Make Array Non-decreasing or Non-increasing
1 parent 01bb9ea commit 5cd6890

File tree

6 files changed

+359
-2
lines changed

6 files changed

+359
-2
lines changed

‎solution/2200-2299/2263.Make Array Non-decreasing or Non-increasing/README.md

Lines changed: 132 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -64,22 +64,153 @@
6464

6565
<!-- 这里可写通用的实现逻辑 -->
6666

67+
**方法一：动态规划**
68+
69+
我们定义 $f[i][j]$ 表示将数组 $nums$ 的前 $i$ 个元素变为非递减序列，且第 $i$ 个元素的值为 $j$ 所需的最小操作次数。由于数组 $nums$ 元素的取值范围为 $[0, 1000]$，因此我们可以将 $f$ 数组的第二维定义为 $1001$。
70+
71+
状态转移方程如下：
72+
73+
$$
74+
f[i][j] = \min_{0 \leq k \leq j} f[i - 1][k] + \left| j - nums[i - 1] \right|
75+
$$
76+
77+
时间复杂度 $O(n \times M)$，空间复杂度 $O(n \times M)$。其中 $n$ 和 $M$ 分别为数组 $nums$ 的长度和数组 $nums$ 元素的取值范围。本题中 $M = 1001$。
78+
79+
由于我们定义的是非递减序列的最小操作次数，因此我们可以将数组 $nums$ 翻转，然后求出非递减序列的最小操作次数，也即是非递增序列的最小操作次数。最后取两者的最小值即可。
80+
6781
<!-- tabs:start -->
6882

6983
### **Python3**
7084

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

7387
```python
74-
88+
class Solution:
89+
def convertArray(self, nums: List[int]) -> int:
90+
def solve(nums):
91+
n = len(nums)
92+
f = [[0] * 1001 for _ in range(n + 1)]
93+
for i, x in enumerate(nums, 1):
94+
mi = inf
95+
for j in range(1001):
96+
if mi > f[i - 1][j]:
97+
mi = f[i - 1][j]
98+
f[i][j] = mi + abs(x - j)
99+
return min(f[n])
100+
101+
return min(solve(nums), solve(nums[::-1]))
75102
```
76103

77104
### **Java**
78105

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

81108
```java
109+
class Solution {
110+
public int convertArray(int[] nums) {
111+
return Math.min(solve(nums), solve(reverse(nums)));
112+
}
113+
114+
private int solve(int[] nums) {
115+
int n = nums.length;
116+
int[][] f = new int[n + 1][1001];
117+
for (int i = 1; i <= n; ++i) {
118+
int mi = 1 << 30;
119+
for (int j = 0; j <= 1000; ++j) {
120+
mi = Math.min(mi, f[i - 1][j]);
121+
f[i][j] = mi + Math.abs(j - nums[i - 1]);
122+
}
123+
}
124+
int ans = 1 << 30;
125+
for (int x : f[n]) {
126+
ans = Math.min(ans, x);
127+
}
128+
return ans;
129+
}
130+
131+
private int[] reverse(int[] nums) {
132+
for (int i = 0, j = nums.length - 1; i < j; ++i, --j) {
133+
int t = nums[i];
134+
nums[i] = nums[j];
135+
nums[j] = t;
136+
}
137+
return nums;
138+
}
139+
}
140+
```
141+
142+
### **C++**
143+
144+
```cpp
145+
class Solution {
146+
public:
147+
int convertArray(vector<int>& nums) {
148+
int a = solve(nums);
149+
reverse(nums.begin(), nums.end());
150+
int b = solve(nums);
151+
return min(a, b);
152+
}
153+
154+
int solve(vector<int>& nums) {
155+
int n = nums.size();
156+
int f[n + 1][1001];
157+
memset(f, 0, sizeof(f));
158+
for (int i = 1; i <= n; ++i) {
159+
int mi = 1 << 30;
160+
for (int j = 0; j <= 1000; ++j) {
161+
mi = min(mi, f[i - 1][j]);
162+
f[i][j] = mi + abs(nums[i - 1] - j);
163+
}
164+
}
165+
return *min_element(f[n], f[n] + 1001);
166+
}
167+
};
168+
```
82169
170+
### **Go**
171+
172+
```go
173+
func convertArray(nums []int) int {
174+
return min(solve(nums), solve(reverse(nums)))
175+
}
176+
177+
func solve(nums []int) int {
178+
n := len(nums)
179+
f := make([][1001]int, n+1)
180+
for i := 1; i <= n; i++ {
181+
mi := 1 << 30
182+
for j := 0; j <= 1000; j++ {
183+
mi = min(mi, f[i-1][j])
184+
f[i][j] = mi + abs(nums[i-1]-j)
185+
}
186+
}
187+
ans := 1 << 30
188+
for _, x := range f[n] {
189+
ans = min(ans, x)
190+
}
191+
return ans
192+
}
193+
194+
func reverse(nums []int) []int {
195+
for i, j := 0, len(nums)-1; i < j; i, j = i+1, j-1 {
196+
nums[i], nums[j] = nums[j], nums[i]
197+
}
198+
return nums
199+
}
200+
201+
func abs(x int) int {
202+
if x < 0 {
203+
return -x
204+
}
205+
return x
206+
}
207+
208+
func min(a, b int) int {
209+
if a < b {
210+
return a
211+
}
212+
return b
213+
}
83214
```
84215

85216
### **TypeScript**

‎solution/2200-2299/2263.Make Array Non-decreasing or Non-increasing/README_EN.md

Lines changed: 118 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -63,13 +63,130 @@ It can be proven that 4 is the minimum number of operations needed.
6363
### **Python3**
6464

6565
```python
66-
66+
class Solution:
67+
def convertArray(self, nums: List[int]) -> int:
68+
def solve(nums):
69+
n = len(nums)
70+
f = [[0] * 1001 for _ in range(n + 1)]
71+
for i, x in enumerate(nums, 1):
72+
mi = inf
73+
for j in range(1001):
74+
if mi > f[i - 1][j]:
75+
mi = f[i - 1][j]
76+
f[i][j] = mi + abs(x - j)
77+
return min(f[n])
78+
79+
return min(solve(nums), solve(nums[::-1]))
6780
```
6881

6982
### **Java**
7083

7184
```java
85+
class Solution {
86+
public int convertArray(int[] nums) {
87+
return Math.min(solve(nums), solve(reverse(nums)));
88+
}
89+
90+
private int solve(int[] nums) {
91+
int n = nums.length;
92+
int[][] f = new int[n + 1][1001];
93+
for (int i = 1; i <= n; ++i) {
94+
int mi = 1 << 30;
95+
for (int j = 0; j <= 1000; ++j) {
96+
mi = Math.min(mi, f[i - 1][j]);
97+
f[i][j] = mi + Math.abs(j - nums[i - 1]);
98+
}
99+
}
100+
int ans = 1 << 30;
101+
for (int x : f[n]) {
102+
ans = Math.min(ans, x);
103+
}
104+
return ans;
105+
}
106+
107+
private int[] reverse(int[] nums) {
108+
for (int i = 0, j = nums.length - 1; i < j; ++i, --j) {
109+
int t = nums[i];
110+
nums[i] = nums[j];
111+
nums[j] = t;
112+
}
113+
return nums;
114+
}
115+
}
116+
```
117+
118+
### **C++**
119+
120+
```cpp
121+
class Solution {
122+
public:
123+
int convertArray(vector<int>& nums) {
124+
int a = solve(nums);
125+
reverse(nums.begin(), nums.end());
126+
int b = solve(nums);
127+
return min(a, b);
128+
}
129+
130+
int solve(vector<int>& nums) {
131+
int n = nums.size();
132+
int f[n + 1][1001];
133+
memset(f, 0, sizeof(f));
134+
for (int i = 1; i <= n; ++i) {
135+
int mi = 1 << 30;
136+
for (int j = 0; j <= 1000; ++j) {
137+
mi = min(mi, f[i - 1][j]);
138+
f[i][j] = mi + abs(nums[i - 1] - j);
139+
}
140+
}
141+
return *min_element(f[n], f[n] + 1001);
142+
}
143+
};
144+
```
72145
146+
### **Go**
147+
148+
```go
149+
func convertArray(nums []int) int {
150+
return min(solve(nums), solve(reverse(nums)))
151+
}
152+
153+
func solve(nums []int) int {
154+
n := len(nums)
155+
f := make([][1001]int, n+1)
156+
for i := 1; i <= n; i++ {
157+
mi := 1 << 30
158+
for j := 0; j <= 1000; j++ {
159+
mi = min(mi, f[i-1][j])
160+
f[i][j] = mi + abs(nums[i-1]-j)
161+
}
162+
}
163+
ans := 1 << 30
164+
for _, x := range f[n] {
165+
ans = min(ans, x)
166+
}
167+
return ans
168+
}
169+
170+
func reverse(nums []int) []int {
171+
for i, j := 0, len(nums)-1; i < j; i, j = i+1, j-1 {
172+
nums[i], nums[j] = nums[j], nums[i]
173+
}
174+
return nums
175+
}
176+
177+
func abs(x int) int {
178+
if x < 0 {
179+
return -x
180+
}
181+
return x
182+
}
183+
184+
func min(a, b int) int {
185+
if a < b {
186+
return a
187+
}
188+
return b
189+
}
73190
```
74191

75192
### **TypeScript**

‎solution/2200-2299/2263.Make Array Non-decreasing or Non-increasing/Solution.cpp

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
class Solution {
2+
public:
3+
int convertArray(vector<int>& nums) {
4+
int a = solve(nums);
5+
reverse(nums.begin(), nums.end());
6+
int b = solve(nums);
7+
return min(a, b);
8+
}
9+
10+
int solve(vector<int>& nums) {
11+
int n = nums.size();
12+
int f[n + 1][1001];
13+
memset(f, 0, sizeof(f));
14+
for (int i = 1; i <= n; ++i) {
15+
int mi = 1 << 30;
16+
for (int j = 0; j <= 1000; ++j) {
17+
mi = min(mi, f[i - 1][j]);
18+
f[i][j] = mi + abs(nums[i - 1] - j);
19+
}
20+
}
21+
return *min_element(f[n], f[n] + 1001);
22+
}
23+
};

‎solution/2200-2299/2263.Make Array Non-decreasing or Non-increasing/Solution.go

Lines changed: 41 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,41 @@
1+
func convertArray(nums []int) int {
2+
return min(solve(nums), solve(reverse(nums)))
3+
}
4+
5+
func solve(nums []int) int {
6+
n := len(nums)
7+
f := make([][1001]int, n+1)
8+
for i := 1; i <= n; i++ {
9+
mi := 1 << 30
10+
for j := 0; j <= 1000; j++ {
11+
mi = min(mi, f[i-1][j])
12+
f[i][j] = mi + abs(nums[i-1]-j)
13+
}
14+
}
15+
ans := 1 << 30
16+
for _, x := range f[n] {
17+
ans = min(ans, x)
18+
}
19+
return ans
20+
}
21+
22+
func reverse(nums []int) []int {
23+
for i, j := 0, len(nums)-1; i < j; i, j = i+1, j-1 {
24+
nums[i], nums[j] = nums[j], nums[i]
25+
}
26+
return nums
27+
}
28+
29+
func abs(x int) int {
30+
if x < 0 {
31+
return -x
32+
}
33+
return x
34+
}
35+
36+
func min(a, b int) int {
37+
if a < b {
38+
return a
39+
}
40+
return b
41+
}

‎solution/2200-2299/2263.Make Array Non-decreasing or Non-increasing/Solution.java

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
class Solution {
2+
public int convertArray(int[] nums) {
3+
return Math.min(solve(nums), solve(reverse(nums)));
4+
}
5+
6+
private int solve(int[] nums) {
7+
int n = nums.length;
8+
int[][] f = new int[n + 1][1001];
9+
for (int i = 1; i <= n; ++i) {
10+
int mi = 1 << 30;
11+
for (int j = 0; j <= 1000; ++j) {
12+
mi = Math.min(mi, f[i - 1][j]);
13+
f[i][j] = mi + Math.abs(j - nums[i - 1]);
14+
}
15+
}
16+
int ans = 1 << 30;
17+
for (int x : f[n]) {
18+
ans = Math.min(ans, x);
19+
}
20+
return ans;
21+
}
22+
23+
private int[] reverse(int[] nums) {
24+
for (int i = 0, j = nums.length - 1; i < j; ++i, --j) {
25+
int t = nums[i];
26+
nums[i] = nums[j];
27+
nums[j] = t;
28+
}
29+
return nums;
30+
}
31+
}

0 commit comments

Comments
 (0)