Skip to content

Commit f8c17f3

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1547
No.1547.Minimum Cost to Cut a Stick
1 parent a4da3fa commit f8c17f3

File tree

3 files changed

+294
-0
lines changed

3 files changed

+294
-0
lines changed

‎solution/1500-1599/1547.Minimum Cost to Cut a Stick/README.md

Lines changed: 114 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -91,6 +91,21 @@ class Solution:
9191
return f[0][-1]
9292
```
9393

94+
```python
95+
class Solution:
96+
def minCost(self, n: int, cuts: List[int]) -> int:
97+
cuts.extend([0, n])
98+
cuts.sort()
99+
m = len(cuts)
100+
f = [[0] * m for _ in range(m)]
101+
for i in range(m - 1, -1, -1):
102+
for j in range(i + 2, m):
103+
f[i][j] = inf
104+
for k in range(i + 1, j):
105+
f[i][j] = min(f[i][j], f[i][k] + f[k][j] + cuts[j] - cuts[i])
106+
return f[0][-1]
107+
```
108+
94109
### **Java**
95110

96111
<!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -121,6 +136,31 @@ class Solution {
121136
}
122137
```
123138

139+
```java
140+
class Solution {
141+
public int minCost(int n, int[] cuts) {
142+
List<Integer> nums = new ArrayList<>();
143+
for (int x : cuts) {
144+
nums.add(x);
145+
}
146+
nums.add(0);
147+
nums.add(n);
148+
Collections.sort(nums);
149+
int m = nums.size();
150+
int[][] f = new int[m][m];
151+
for (int i = m - 1; i >= 0; --i) {
152+
for (int j = i + 2; j < m; ++j) {
153+
f[i][j] = 1 << 30;
154+
for (int k = i + 1; k < j; ++k) {
155+
f[i][j] = Math.min(f[i][j], f[i][k] + f[k][j] + nums.get(j) - nums.get(i));
156+
}
157+
}
158+
}
159+
return f[0][m - 1];
160+
}
161+
}
162+
```
163+
124164
### **C++**
125165

126166
```cpp
@@ -146,6 +186,28 @@ public:
146186
};
147187
```
148188
189+
```cpp
190+
class Solution {
191+
public:
192+
int minCost(int n, vector<int>& cuts) {
193+
cuts.push_back(0);
194+
cuts.push_back(n);
195+
sort(cuts.begin(), cuts.end());
196+
int m = cuts.size();
197+
int f[110][110]{};
198+
for (int i = m - 1; ~i; --i) {
199+
for (int j = i + 2; j < m; ++j) {
200+
f[i][j] = 1 << 30;
201+
for (int k = i + 1; k < j; ++k) {
202+
f[i][j] = min(f[i][j], f[i][k] + f[k][j] + cuts[j] - cuts[i]);
203+
}
204+
}
205+
}
206+
return f[0][m - 1];
207+
}
208+
};
209+
```
210+
149211
### **Go**
150212

151213
```go
@@ -177,6 +239,58 @@ func min(a, b int) int {
177239
}
178240
```
179241

242+
```go
243+
func minCost(n int, cuts []int) int {
244+
cuts = append(cuts, []int{0, n}...)
245+
sort.Ints(cuts)
246+
m := len(cuts)
247+
f := make([][]int, m)
248+
for i := range f {
249+
f[i] = make([]int, m)
250+
}
251+
for i := m - 1; i >= 0; i-- {
252+
for j := i + 2; j < m; j++ {
253+
f[i][j] = 1 << 30
254+
for k := i + 1; k < j; k++ {
255+
f[i][j] = min(f[i][j], f[i][k]+f[k][j]+cuts[j]-cuts[i])
256+
}
257+
}
258+
}
259+
return f[0][m-1]
260+
}
261+
262+
func min(a, b int) int {
263+
if a < b {
264+
return a
265+
}
266+
return b
267+
}
268+
```
269+
270+
### **TypeScript**
271+
272+
```ts
273+
function minCost(n: number, cuts: number[]): number {
274+
cuts.push(0);
275+
cuts.push(n);
276+
cuts.sort((a, b) => a - b);
277+
const m = cuts.length;
278+
const f: number[][] = new Array(m).fill(0).map(() => new Array(m).fill(0));
279+
for (let i = m - 2; i >= 0; --i) {
280+
for (let j = i + 2; j < m; ++j) {
281+
f[i][j] = 1 << 30;
282+
for (let k = i + 1; k < j; ++k) {
283+
f[i][j] = Math.min(
284+
f[i][j],
285+
f[i][k] + f[k][j] + cuts[j] - cuts[i],
286+
);
287+
}
288+
}
289+
}
290+
return f[0][m - 1];
291+
}
292+
```
293+
180294
### **...**
181295

182296
```

‎solution/1500-1599/1547.Minimum Cost to Cut a Stick/README_EN.md

Lines changed: 160 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -66,6 +66,21 @@ class Solution:
6666
return f[0][-1]
6767
```
6868

69+
```python
70+
class Solution:
71+
def minCost(self, n: int, cuts: List[int]) -> int:
72+
cuts.extend([0, n])
73+
cuts.sort()
74+
m = len(cuts)
75+
f = [[0] * m for _ in range(m)]
76+
for i in range(m - 1, -1, -1):
77+
for j in range(i + 2, m):
78+
f[i][j] = inf
79+
for k in range(i + 1, j):
80+
f[i][j] = min(f[i][j], f[i][k] + f[k][j] + cuts[j] - cuts[i])
81+
return f[0][-1]
82+
```
83+
6984
### **Java**
7085

7186
```java
@@ -94,6 +109,31 @@ class Solution {
94109
}
95110
```
96111

112+
```java
113+
class Solution {
114+
public int minCost(int n, int[] cuts) {
115+
List<Integer> nums = new ArrayList<>();
116+
for (int x : cuts) {
117+
nums.add(x);
118+
}
119+
nums.add(0);
120+
nums.add(n);
121+
Collections.sort(nums);
122+
int m = nums.size();
123+
int[][] f = new int[m][m];
124+
for (int i = m - 1; i >= 0; --i) {
125+
for (int j = i + 2; j < m; ++j) {
126+
f[i][j] = 1 << 30;
127+
for (int k = i + 1; k < j; ++k) {
128+
f[i][j] = Math.min(f[i][j], f[i][k] + f[k][j] + nums.get(j) - nums.get(i));
129+
}
130+
}
131+
}
132+
return f[0][m - 1];
133+
}
134+
}
135+
```
136+
97137
### **C++**
98138

99139
```cpp
@@ -119,6 +159,28 @@ public:
119159
};
120160
```
121161
162+
```cpp
163+
class Solution {
164+
public:
165+
int minCost(int n, vector<int>& cuts) {
166+
cuts.push_back(0);
167+
cuts.push_back(n);
168+
sort(cuts.begin(), cuts.end());
169+
int m = cuts.size();
170+
int f[110][110]{};
171+
for (int i = m - 1; ~i; --i) {
172+
for (int j = i + 2; j < m; ++j) {
173+
f[i][j] = 1 << 30;
174+
for (int k = i + 1; k < j; ++k) {
175+
f[i][j] = min(f[i][j], f[i][k] + f[k][j] + cuts[j] - cuts[i]);
176+
}
177+
}
178+
}
179+
return f[0][m - 1];
180+
}
181+
};
182+
```
183+
122184
### **Go**
123185

124186
```go
@@ -150,6 +212,104 @@ func min(a, b int) int {
150212
}
151213
```
152214

215+
```go
216+
func minCost(n int, cuts []int) int {
217+
cuts = append(cuts, []int{0, n}...)
218+
sort.Ints(cuts)
219+
m := len(cuts)
220+
f := make([][]int, m)
221+
for i := range f {
222+
f[i] = make([]int, m)
223+
}
224+
for i := m - 1; i >= 0; i-- {
225+
for j := i + 2; j < m; j++ {
226+
f[i][j] = 1 << 30
227+
for k := i + 1; k < j; k++ {
228+
f[i][j] = min(f[i][j], f[i][k]+f[k][j]+cuts[j]-cuts[i])
229+
}
230+
}
231+
}
232+
return f[0][m-1]
233+
}
234+
235+
func min(a, b int) int {
236+
if a < b {
237+
return a
238+
}
239+
return b
240+
}
241+
```
242+
243+
### **TypeScript**
244+
245+
```ts
246+
function minCost(n: number, cuts: number[]): number {
247+
cuts.push(0);
248+
cuts.push(n);
249+
cuts.sort((a, b) => a - b);
250+
const m = cuts.length;
251+
const f: number[][] = new Array(m).fill(0).map(() => new Array(m).fill(0));
252+
for (let l = 2; l < m; ++l) {
253+
for (let i = 0; i + l < m; ++i) {
254+
const j = i + l;
255+
f[i][j] = 1 << 30;
256+
for (let k = i + 1; k < j; ++k) {
257+
f[i][j] = Math.min(
258+
f[i][j],
259+
f[i][k] + f[k][j] + cuts[j] - cuts[i],
260+
);
261+
}
262+
}
263+
}
264+
return f[0][m - 1];
265+
}
266+
```
267+
268+
```ts
269+
function minCost(n: number, cuts: number[]): number {
270+
cuts.push(0);
271+
cuts.push(n);
272+
cuts.sort((a, b) => a - b);
273+
const m = cuts.length;
274+
const f: number[][] = new Array(m).fill(0).map(() => new Array(m).fill(0));
275+
for (let l = 2; l < m; ++l) {
276+
for (let i = 0; i + l < m; ++i) {
277+
const j = i + l;
278+
f[i][j] = 1 << 30;
279+
for (let k = i + 1; k < j; ++k) {
280+
f[i][j] = Math.min(
281+
f[i][j],
282+
f[i][k] + f[k][j] + cuts[j] - cuts[i],
283+
);
284+
}
285+
}
286+
}
287+
return f[0][m - 1];
288+
}
289+
```
290+
291+
```ts
292+
function minCost(n: number, cuts: number[]): number {
293+
cuts.push(0);
294+
cuts.push(n);
295+
cuts.sort((a, b) => a - b);
296+
const m = cuts.length;
297+
const f: number[][] = new Array(m).fill(0).map(() => new Array(m).fill(0));
298+
for (let i = m - 2; i >= 0; --i) {
299+
for (let j = i + 2; j < m; ++j) {
300+
f[i][j] = 1 << 30;
301+
for (let k = i + 1; k < j; ++k) {
302+
f[i][j] = Math.min(
303+
f[i][j],
304+
f[i][k] + f[k][j] + cuts[j] - cuts[i],
305+
);
306+
}
307+
}
308+
}
309+
return f[0][m - 1];
310+
}
311+
```
312+
153313
### **...**
154314

155315
```

‎solution/1500-1599/1547.Minimum Cost to Cut a Stick/Solution.ts

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
function minCost(n: number, cuts: number[]): number {
2+
cuts.push(0);
3+
cuts.push(n);
4+
cuts.sort((a, b) => a - b);
5+
const m = cuts.length;
6+
const f: number[][] = new Array(m).fill(0).map(() => new Array(m).fill(0));
7+
for (let l = 2; l < m; ++l) {
8+
for (let i = 0; i + l < m; ++i) {
9+
const j = i + l;
10+
f[i][j] = 1 << 30;
11+
for (let k = i + 1; k < j; ++k) {
12+
f[i][j] = Math.min(
13+
f[i][j],
14+
f[i][k] + f[k][j] + cuts[j] - cuts[i],
15+
);
16+
}
17+
}
18+
}
19+
return f[0][m - 1];
20+
}

0 commit comments

Comments
 (0)