Skip to content

Commit ef484f4

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

File tree

6 files changed

+278
-2
lines changed

6 files changed

+278
-2
lines changed

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

Lines changed: 105 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -55,22 +55,126 @@
5555

5656
<!-- 这里可写通用的实现逻辑 -->
5757

58+
**方法一：动态规划（区间 DP）**
59+
60+
我们可以往切割点数组 $cuts$ 中添加两个元素，分别是 $0$ 和 $n$，表示棍子的两端。然后我们对 $cuts$ 数组进行排序，这样我们就可以将整个棍子切割为若干个区间，每个区间都有两个切割点。不妨设此时 $cuts$ 数组的长度为 $m$。
61+
62+
接下来，我们定义 $f[i][j]$ 表示切割区间 $[cuts[i],..cuts[j]]$ 的最小成本。
63+
64+
如果一个区间只有两个切割点，也就是说，我们无需切割这个区间，那么 $f[i][j] = 0$。
65+
66+
否则，我们枚举区间的长度 $l$，其中 $l$ 等于切割点的数量减去 $1$。然后我们枚举区间的左端点 $i$，右端点 $j$ 可以由 $i + l$ 得到。对于每个区间，我们枚举它的切割点 $k$，其中 $i \lt k \lt j$，那么我们可以将区间 $[i, j]$ 切割为 $[i, k]$ 和 $[k, j]$，此时的成本为 $f[i][k] + f[k][j] + cuts[j] - cuts[i]$，我们取所有可能的 $k$ 中的最小值，即为 $f[i][j]$ 的值。
67+
68+
最后，我们返回 $f[0][m - 1]$。
69+
70+
时间复杂度 $O(m^3)$，空间复杂度 $O(m^2)$。其中 $m$ 为修改后的 $cuts$ 数组的长度。
71+
5872
<!-- tabs:start -->
5973

6074
### **Python3**
6175

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

6478
```python
65-
79+
class Solution:
80+
def minCost(self, n: int, cuts: List[int]) -> int:
81+
cuts.extend([0, n])
82+
cuts.sort()
83+
m = len(cuts)
84+
f = [[0] * m for _ in range(m)]
85+
for l in range(2, m):
86+
for i in range(m - l):
87+
j = i + l
88+
f[i][j] = inf
89+
for k in range(i + 1, j):
90+
f[i][j] = min(f[i][j], f[i][k] + f[k][j] + cuts[j] - cuts[i])
91+
return f[0][-1]
6692
```
6793

6894
### **Java**
6995

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

7298
```java
99+
class Solution {
100+
public int minCost(int n, int[] cuts) {
101+
List<Integer> nums = new ArrayList<>();
102+
for (int x : cuts) {
103+
nums.add(x);
104+
}
105+
nums.add(0);
106+
nums.add(n);
107+
Collections.sort(nums);
108+
int m = nums.size();
109+
int[][] f = new int[m][m];
110+
for (int l = 2; l < m; ++l) {
111+
for (int i = 0; i + l < m; ++i) {
112+
int j = i + l;
113+
f[i][j] = 1 << 30;
114+
for (int k = i + 1; k < j; ++k) {
115+
f[i][j] = Math.min(f[i][j], f[i][k] + f[k][j] + nums.get(j) - nums.get(i));
116+
}
117+
}
118+
}
119+
return f[0][m - 1];
120+
}
121+
}
122+
```
123+
124+
### **C++**
125+
126+
```cpp
127+
class Solution {
128+
public:
129+
int minCost(int n, vector<int>& cuts) {
130+
cuts.push_back(0);
131+
cuts.push_back(n);
132+
sort(cuts.begin(), cuts.end());
133+
int m = cuts.size();
134+
int f[110][110]{};
135+
for (int l = 2; l < m; ++l) {
136+
for (int i = 0; i + l < m; ++i) {
137+
int j = i + l;
138+
f[i][j] = 1 << 30;
139+
for (int k = i + 1; k < j; ++k) {
140+
f[i][j] = min(f[i][j], f[i][k] + f[k][j] + cuts[j] - cuts[i]);
141+
}
142+
}
143+
}
144+
return f[0][m - 1];
145+
}
146+
};
147+
```
73148
149+
### **Go**
150+
151+
```go
152+
func minCost(n int, cuts []int) int {
153+
cuts = append(cuts, []int{0, n}...)
154+
sort.Ints(cuts)
155+
m := len(cuts)
156+
f := make([][]int, m)
157+
for i := range f {
158+
f[i] = make([]int, m)
159+
}
160+
for l := 2; l < m; l++ {
161+
for i := 0; i+l < m; i++ {
162+
j := i + l
163+
f[i][j] = 1 << 30
164+
for k := i + 1; k < j; k++ {
165+
f[i][j] = min(f[i][j], f[i][k]+f[k][j]+cuts[j]-cuts[i])
166+
}
167+
}
168+
}
169+
return f[0][m-1]
170+
}
171+
172+
func min(a, b int) int {
173+
if a < b {
174+
return a
175+
}
176+
return b
177+
}
74178
```
75179

76180
### **...**

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

Lines changed: 91 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -51,13 +51,103 @@ There are much ordering with total cost &lt;= 25, for example, the order [4, 6,
5151
### **Python3**
5252

5353
```python
54-
54+
class Solution:
55+
def minCost(self, n: int, cuts: List[int]) -> int:
56+
cuts.extend([0, n])
57+
cuts.sort()
58+
m = len(cuts)
59+
f = [[0] * m for _ in range(m)]
60+
for l in range(2, m):
61+
for i in range(m - l):
62+
j = i + l
63+
f[i][j] = inf
64+
for k in range(i + 1, j):
65+
f[i][j] = min(f[i][j], f[i][k] + f[k][j] + cuts[j] - cuts[i])
66+
return f[0][-1]
5567
```
5668

5769
### **Java**
5870

5971
```java
72+
class Solution {
73+
public int minCost(int n, int[] cuts) {
74+
List<Integer> nums = new ArrayList<>();
75+
for (int x : cuts) {
76+
nums.add(x);
77+
}
78+
nums.add(0);
79+
nums.add(n);
80+
Collections.sort(nums);
81+
int m = nums.size();
82+
int[][] f = new int[m][m];
83+
for (int l = 2; l < m; ++l) {
84+
for (int i = 0; i + l < m; ++i) {
85+
int j = i + l;
86+
f[i][j] = 1 << 30;
87+
for (int k = i + 1; k < j; ++k) {
88+
f[i][j] = Math.min(f[i][j], f[i][k] + f[k][j] + nums.get(j) - nums.get(i));
89+
}
90+
}
91+
}
92+
return f[0][m - 1];
93+
}
94+
}
95+
```
96+
97+
### **C++**
98+
99+
```cpp
100+
class Solution {
101+
public:
102+
int minCost(int n, vector<int>& cuts) {
103+
cuts.push_back(0);
104+
cuts.push_back(n);
105+
sort(cuts.begin(), cuts.end());
106+
int m = cuts.size();
107+
int f[110][110]{};
108+
for (int l = 2; l < m; ++l) {
109+
for (int i = 0; i + l < m; ++i) {
110+
int j = i + l;
111+
f[i][j] = 1 << 30;
112+
for (int k = i + 1; k < j; ++k) {
113+
f[i][j] = min(f[i][j], f[i][k] + f[k][j] + cuts[j] - cuts[i]);
114+
}
115+
}
116+
}
117+
return f[0][m - 1];
118+
}
119+
};
120+
```
60121
122+
### **Go**
123+
124+
```go
125+
func minCost(n int, cuts []int) int {
126+
cuts = append(cuts, []int{0, n}...)
127+
sort.Ints(cuts)
128+
m := len(cuts)
129+
f := make([][]int, m)
130+
for i := range f {
131+
f[i] = make([]int, m)
132+
}
133+
for l := 2; l < m; l++ {
134+
for i := 0; i+l < m; i++ {
135+
j := i + l
136+
f[i][j] = 1 << 30
137+
for k := i + 1; k < j; k++ {
138+
f[i][j] = min(f[i][j], f[i][k]+f[k][j]+cuts[j]-cuts[i])
139+
}
140+
}
141+
}
142+
return f[0][m-1]
143+
}
144+
145+
func min(a, b int) int {
146+
if a < b {
147+
return a
148+
}
149+
return b
150+
}
61151
```
62152

63153
### **...**

‎solution/1500-1599/1547.Minimum Cost to Cut a Stick/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 minCost(int n, vector<int>& cuts) {
4+
cuts.push_back(0);
5+
cuts.push_back(n);
6+
sort(cuts.begin(), cuts.end());
7+
int m = cuts.size();
8+
int f[110][110]{};
9+
for (int l = 2; l < m; ++l) {
10+
for (int i = 0; i + l < m; ++i) {
11+
int j = i + l;
12+
f[i][j] = 1 << 30;
13+
for (int k = i + 1; k < j; ++k) {
14+
f[i][j] = min(f[i][j], f[i][k] + f[k][j] + cuts[j] - cuts[i]);
15+
}
16+
}
17+
}
18+
return f[0][m - 1];
19+
}
20+
};

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

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
func minCost(n int, cuts []int) int {
2+
cuts = append(cuts, []int{0, n}...)
3+
sort.Ints(cuts)
4+
m := len(cuts)
5+
f := make([][]int, m)
6+
for i := range f {
7+
f[i] = make([]int, m)
8+
}
9+
for l := 2; l < m; l++ {
10+
for i := 0; i+l < m; i++ {
11+
j := i + l
12+
f[i][j] = 1 << 30
13+
for k := i + 1; k < j; k++ {
14+
f[i][j] = min(f[i][j], f[i][k]+f[k][j]+cuts[j]-cuts[i])
15+
}
16+
}
17+
}
18+
return f[0][m-1]
19+
}
20+
21+
func min(a, b int) int {
22+
if a < b {
23+
return a
24+
}
25+
return b
26+
}

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

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
class Solution {
2+
public int minCost(int n, int[] cuts) {
3+
List<Integer> nums = new ArrayList<>();
4+
for (int x : cuts) {
5+
nums.add(x);
6+
}
7+
nums.add(0);
8+
nums.add(n);
9+
Collections.sort(nums);
10+
int m = nums.size();
11+
int[][] f = new int[m][m];
12+
for (int l = 2; l < m; ++l) {
13+
for (int i = 0; i + l < m; ++i) {
14+
int j = i + l;
15+
f[i][j] = 1 << 30;
16+
for (int k = i + 1; k < j; ++k) {
17+
f[i][j] = Math.min(f[i][j], f[i][k] + f[k][j] + nums.get(j) - nums.get(i));
18+
}
19+
}
20+
}
21+
return f[0][m - 1];
22+
}
23+
}

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

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
class Solution:
2+
def minCost(self, n: int, cuts: List[int]) -> int:
3+
cuts.extend([0, n])
4+
cuts.sort()
5+
m = len(cuts)
6+
f = [[0] * m for _ in range(m)]
7+
for l in range(2, m):
8+
for i in range(m - l):
9+
j = i + l
10+
f[i][j] = inf
11+
for k in range(i + 1, j):
12+
f[i][j] = min(f[i][j], f[i][k] + f[k][j] + cuts[j] - cuts[i])
13+
return f[0][-1]

0 commit comments

Comments
 (0)