Skip to content

Commit 17b3b50

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0546
No.0546.Remove Boxes
1 parent bfc8ad5 commit 17b3b50

File tree

6 files changed

+369
-2
lines changed

6 files changed

+369
-2
lines changed

‎solution/0500-0599/0546.Remove Boxes/README.md

+134-1
Original file line numberDiff line numberDiff line change
@@ -54,22 +54,155 @@
5454

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

57+
**方法一：记忆化搜索**
58+
59+
设计递归函数 `dfs(i, j, k)` 表示当前处理的区间为 `[i, j]`，且该区间的右边有 `k` 个与 `boxes[j]` 相同的元素，返回该区间的最大积分。答案即为 `dfs(0, n - 1, 0)`。
60+
61+
对于 `dfs(i, j, k)`，我们可以直接删除 `boxes[j]` 和其右边的 `k` 个元素，所得积分为 `dfs(i, j - 1, 0) + (k + 1) * (k + 1)`。
62+
63+
我们还可以在区间 `[i, j-1]` 内枚举下标 `h`，找到满足 `boxes[h] == boxes[j]` 的下标，那么我们就将区间 `[i, j - 1]` 分成两部分，即 `[i, h]` 和 `[h + 1, j - 1]`。其中 `[i, h]` 的部分可以与 `boxes[j]` 合并，所以积分为 `dfs(i, h, k + 1) + dfs(h + 1, j - 1, 0)`。求不同 `h` 下的最大值即可。
64+
65+
我们使用记忆化搜索来优化递归函数的时间复杂度。
66+
67+
时间复杂度 $O(n^4)$，空间复杂度 $O(n^3)$。
68+
5769
<!-- tabs:start -->
5870

5971
### **Python3**
6072

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

6375
```python
64-
76+
class Solution:
77+
def removeBoxes(self, boxes: List[int]) -> int:
78+
@cache
79+
def dfs(i, j, k):
80+
if i > j:
81+
return 0
82+
while i < j and boxes[j] == boxes[j - 1]:
83+
j, k = j - 1, k + 1
84+
ans = dfs(i, j - 1, 0) + (k + 1) * (k + 1)
85+
for h in range(i, j):
86+
if boxes[h] == boxes[j]:
87+
ans = max(ans, dfs(h + 1, j - 1, 0) + dfs(i, h, k + 1))
88+
return ans
89+
90+
n = len(boxes)
91+
ans = dfs(0, n - 1, 0)
92+
dfs.cache_clear()
93+
return ans
6594
```
6695

6796
### **Java**
6897

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

71100
```java
101+
class Solution {
102+
private int[][][] f;
103+
private int[] b;
104+
105+
public int removeBoxes(int[] boxes) {
106+
b = boxes;
107+
int n = b.length;
108+
f = new int[n][n][n];
109+
return dfs(0, n - 1, 0);
110+
}
111+
112+
private int dfs(int i, int j, int k) {
113+
if (i > j) {
114+
return 0;
115+
}
116+
while (i < j && b[j] == b[j - 1]) {
117+
--j;
118+
++k;
119+
}
120+
if (f[i][j][k] > 0) {
121+
return f[i][j][k];
122+
}
123+
int ans = dfs(i, j - 1, 0) + (k + 1) * (k + 1);
124+
for (int h = i; h < j; ++h) {
125+
if (b[h] == b[j]) {
126+
ans = Math.max(ans, dfs(h + 1, j - 1, 0) + dfs(i, h, k + 1));
127+
}
128+
}
129+
f[i][j][k] = ans;
130+
return ans;
131+
}
132+
}
133+
```
134+
135+
### **C++**
136+
137+
```cpp
138+
class Solution {
139+
public:
140+
int removeBoxes(vector<int>& boxes) {
141+
int n = boxes.size();
142+
vector<vector<vector<int>>> f(n, vector<vector<int>>(n, vector<int>(n)));
143+
function<int(int, int, int)> dfs;
144+
dfs = [&](int i, int j, int k) {
145+
if (i > j) return 0;
146+
while (i < j && boxes[j] == boxes[j - 1]) {
147+
--j;
148+
++k;
149+
}
150+
if (f[i][j][k]) return f[i][j][k];
151+
int ans = dfs(i, j - 1, 0) + (k + 1) * (k + 1);
152+
for (int h = i; h < j; ++h) {
153+
if (boxes[h] == boxes[j]) {
154+
ans = max(ans, dfs(h + 1, j - 1, 0) + dfs(i, h, k + 1));
155+
}
156+
}
157+
f[i][j][k] = ans;
158+
return ans;
159+
};
160+
return dfs(0, n - 1, 0);
161+
}
162+
};
163+
```
72164
165+
### **Go**
166+
167+
```go
168+
func removeBoxes(boxes []int) int {
169+
n := len(boxes)
170+
f := make([][][]int, n)
171+
for i := range f {
172+
f[i] = make([][]int, n)
173+
for j := range f[i] {
174+
f[i][j] = make([]int, n)
175+
}
176+
}
177+
var dfs func(i, j, k int) int
178+
dfs = func(i, j, k int) int {
179+
if i > j {
180+
return 0
181+
}
182+
for i < j && boxes[j] == boxes[j-1] {
183+
j, k = j-1, k+1
184+
}
185+
if f[i][j][k] > 0 {
186+
return f[i][j][k]
187+
}
188+
ans := dfs(i, j-1, 0) + (k+1)*(k+1)
189+
for h := i; h < j; h++ {
190+
if boxes[h] == boxes[j] {
191+
ans = max(ans, dfs(h+1, j-1, 0)+dfs(i, h, k+1))
192+
}
193+
}
194+
f[i][j][k] = ans
195+
return ans
196+
}
197+
return dfs(0, n-1, 0)
198+
}
199+
200+
func max(a, b int) int {
201+
if a > b {
202+
return a
203+
}
204+
return b
205+
}
73206
```
74207

75208
### **...**

‎solution/0500-0599/0546.Remove Boxes/README_EN.md

+122-1
Original file line numberDiff line numberDiff line change
@@ -53,13 +53,134 @@
5353
### **Python3**
5454

5555
```python
56-
56+
class Solution:
57+
def removeBoxes(self, boxes: List[int]) -> int:
58+
@cache
59+
def dfs(i, j, k):
60+
if i > j:
61+
return 0
62+
while i < j and boxes[j] == boxes[j - 1]:
63+
j, k = j - 1, k + 1
64+
ans = dfs(i, j - 1, 0) + (k + 1) * (k + 1)
65+
for h in range(i, j):
66+
if boxes[h] == boxes[j]:
67+
ans = max(ans, dfs(h + 1, j - 1, 0) + dfs(i, h, k + 1))
68+
return ans
69+
70+
n = len(boxes)
71+
ans = dfs(0, n - 1, 0)
72+
dfs.cache_clear()
73+
return ans
5774
```
5875

5976
### **Java**
6077

6178
```java
79+
class Solution {
80+
private int[][][] f;
81+
private int[] b;
82+
83+
public int removeBoxes(int[] boxes) {
84+
b = boxes;
85+
int n = b.length;
86+
f = new int[n][n][n];
87+
return dfs(0, n - 1, 0);
88+
}
89+
90+
private int dfs(int i, int j, int k) {
91+
if (i > j) {
92+
return 0;
93+
}
94+
while (i < j && b[j] == b[j - 1]) {
95+
--j;
96+
++k;
97+
}
98+
if (f[i][j][k] > 0) {
99+
return f[i][j][k];
100+
}
101+
int ans = dfs(i, j - 1, 0) + (k + 1) * (k + 1);
102+
for (int h = i; h < j; ++h) {
103+
if (b[h] == b[j]) {
104+
ans = Math.max(ans, dfs(h + 1, j - 1, 0) + dfs(i, h, k + 1));
105+
}
106+
}
107+
f[i][j][k] = ans;
108+
return ans;
109+
}
110+
}
111+
```
112+
113+
### **C++**
114+
115+
```cpp
116+
class Solution {
117+
public:
118+
int removeBoxes(vector<int>& boxes) {
119+
int n = boxes.size();
120+
vector<vector<vector<int>>> f(n, vector<vector<int>>(n, vector<int>(n)));
121+
function<int(int, int, int)> dfs;
122+
dfs = [&](int i, int j, int k) {
123+
if (i > j) return 0;
124+
while (i < j && boxes[j] == boxes[j - 1]) {
125+
--j;
126+
++k;
127+
}
128+
if (f[i][j][k]) return f[i][j][k];
129+
int ans = dfs(i, j - 1, 0) + (k + 1) * (k + 1);
130+
for (int h = i; h < j; ++h) {
131+
if (boxes[h] == boxes[j]) {
132+
ans = max(ans, dfs(h + 1, j - 1, 0) + dfs(i, h, k + 1));
133+
}
134+
}
135+
f[i][j][k] = ans;
136+
return ans;
137+
};
138+
return dfs(0, n - 1, 0);
139+
}
140+
};
141+
```
62142
143+
### **Go**
144+
145+
```go
146+
func removeBoxes(boxes []int) int {
147+
n := len(boxes)
148+
f := make([][][]int, n)
149+
for i := range f {
150+
f[i] = make([][]int, n)
151+
for j := range f[i] {
152+
f[i][j] = make([]int, n)
153+
}
154+
}
155+
var dfs func(i, j, k int) int
156+
dfs = func(i, j, k int) int {
157+
if i > j {
158+
return 0
159+
}
160+
for i < j && boxes[j] == boxes[j-1] {
161+
j, k = j-1, k+1
162+
}
163+
if f[i][j][k] > 0 {
164+
return f[i][j][k]
165+
}
166+
ans := dfs(i, j-1, 0) + (k+1)*(k+1)
167+
for h := i; h < j; h++ {
168+
if boxes[h] == boxes[j] {
169+
ans = max(ans, dfs(h+1, j-1, 0)+dfs(i, h, k+1))
170+
}
171+
}
172+
f[i][j][k] = ans
173+
return ans
174+
}
175+
return dfs(0, n-1, 0)
176+
}
177+
178+
func max(a, b int) int {
179+
if a > b {
180+
return a
181+
}
182+
return b
183+
}
63184
```
64185

65186
### **...**

‎solution/0500-0599/0546.Remove Boxes/Solution.cpp

+25
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
class Solution {
2+
public:
3+
int removeBoxes(vector<int>& boxes) {
4+
int n = boxes.size();
5+
vector<vector<vector<int>>> f(n, vector<vector<int>>(n, vector<int>(n)));
6+
function<int(int, int, int)> dfs;
7+
dfs = [&](int i, int j, int k) {
8+
if (i > j) return 0;
9+
while (i < j && boxes[j] == boxes[j - 1]) {
10+
--j;
11+
++k;
12+
}
13+
if (f[i][j][k]) return f[i][j][k];
14+
int ans = dfs(i, j - 1, 0) + (k + 1) * (k + 1);
15+
for (int h = i; h < j; ++h) {
16+
if (boxes[h] == boxes[j]) {
17+
ans = max(ans, dfs(h + 1, j - 1, 0) + dfs(i, h, k + 1));
18+
}
19+
}
20+
f[i][j][k] = ans;
21+
return ans;
22+
};
23+
return dfs(0, n - 1, 0);
24+
}
25+
};

‎solution/0500-0599/0546.Remove Boxes/Solution.go

+38
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
1+
func removeBoxes(boxes []int) int {
2+
n := len(boxes)
3+
f := make([][][]int, n)
4+
for i := range f {
5+
f[i] = make([][]int, n)
6+
for j := range f[i] {
7+
f[i][j] = make([]int, n)
8+
}
9+
}
10+
var dfs func(i, j, k int) int
11+
dfs = func(i, j, k int) int {
12+
if i > j {
13+
return 0
14+
}
15+
for i < j && boxes[j] == boxes[j-1] {
16+
j, k = j-1, k+1
17+
}
18+
if f[i][j][k] > 0 {
19+
return f[i][j][k]
20+
}
21+
ans := dfs(i, j-1, 0) + (k+1)*(k+1)
22+
for h := i; h < j; h++ {
23+
if boxes[h] == boxes[j] {
24+
ans = max(ans, dfs(h+1, j-1, 0)+dfs(i, h, k+1))
25+
}
26+
}
27+
f[i][j][k] = ans
28+
return ans
29+
}
30+
return dfs(0, n-1, 0)
31+
}
32+
33+
func max(a, b int) int {
34+
if a > b {
35+
return a
36+
}
37+
return b
38+
}

‎solution/0500-0599/0546.Remove Boxes/Solution.java

+32
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
class Solution {
2+
private int[][][] f;
3+
private int[] b;
4+
5+
public int removeBoxes(int[] boxes) {
6+
b = boxes;
7+
int n = b.length;
8+
f = new int[n][n][n];
9+
return dfs(0, n - 1, 0);
10+
}
11+
12+
private int dfs(int i, int j, int k) {
13+
if (i > j) {
14+
return 0;
15+
}
16+
while (i < j && b[j] == b[j - 1]) {
17+
--j;
18+
++k;
19+
}
20+
if (f[i][j][k] > 0) {
21+
return f[i][j][k];
22+
}
23+
int ans = dfs(i, j - 1, 0) + (k + 1) * (k + 1);
24+
for (int h = i; h < j; ++h) {
25+
if (b[h] == b[j]) {
26+
ans = Math.max(ans, dfs(h + 1, j - 1, 0) + dfs(i, h, k + 1));
27+
}
28+
}
29+
f[i][j][k] = ans;
30+
return ans;
31+
}
32+
}

0 commit comments

Comments
 (0)