Skip to content

Commit 74a8576

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lcci problem: No.08.13 (#1391)
No.08.13.Pile Box
1 parent da96ca4 commit 74a8576

File tree

7 files changed

+309
-2
lines changed

7 files changed

+309
-2
lines changed

‎lcci/08.13.Pile Box/README.md

+115-1
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@
55
## 题目描述
66

77
<!-- 这里写题目描述 -->
8+
89
<p>堆箱子。给你一堆n个箱子，箱子宽 wi、高hi、深di。箱子不能翻转，将箱子堆起来时，下面箱子的宽度、高度和深度必须大于上面的箱子。实现一种方法，搭出最高的一堆箱子。箱堆的高度为每个箱子高度的总和。</p>
910
<p>输入使用数组<code>[wi, di, hi]</code>表示每个箱子。</p>
1011
<p><strong>示例1:</strong></p>
@@ -24,22 +25,135 @@
2425

2526
<!-- 这里可写通用的实现逻辑 -->
2627

28+
**方法一：排序 + 动态规划**
29+
30+
我们先将箱子按照宽度升序、深度降序的顺序进行排序，然后使用动态规划求解。
31+
32+
定义 $f[i]$ 表示以第 $i$ 个箱子为底部的最大高度。对于 $f[i]$，我们枚举 $j \in [0, i)$，如果 $box[j][1] \lt box[i][1]$ 且 $box[j][2] \lt box[i][2]$，那么我们可以将第 $j$ 个箱子放在第 $i$ 个箱子上面，此时 $f[i] = \max\{f[i], f[j]\}$。最后我们将 $f[i]$ 加上第 $i$ 个箱子的高度，即可得到 $f[i]$ 的最终值。
33+
34+
答案为 $f$ 中的最大值。
35+
36+
时间复杂度 $O(n^2)$，空间复杂度 $O(n)$。其中 $n$ 是箱子的数目。
37+
2738
<!-- tabs:start -->
2839

2940
### **Python3**
3041

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

3344
```python
34-
45+
class Solution:
46+
def pileBox(self, box: List[List[int]]) -> int:
47+
box.sort(key=lambda x: (x[0], -x[1]))
48+
n = len(box)
49+
f = [0] * n
50+
for i in range(n):
51+
for j in range(i):
52+
if box[j][1] < box[i][1] and box[j][2] < box[i][2]:
53+
f[i] = max(f[i], f[j])
54+
f[i] += box[i][2]
55+
return max(f)
3556
```
3657

3758
### **Java**
3859

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

4162
```java
63+
class Solution {
64+
public int pileBox(int[][] box) {
65+
Arrays.sort(box, (a, b) -> a[0] == b[0] ? b[1] - a[1] : a[0] - b[0]);
66+
int n = box.length;
67+
int[] f = new int[n];
68+
int ans = 0;
69+
for (int i = 0; i < n; ++i) {
70+
for (int j = 0; j < i; ++j) {
71+
if (box[j][1] < box[i][1] && box[j][2] < box[i][2]) {
72+
f[i] = Math.max(f[i], f[j]);
73+
}
74+
}
75+
f[i] += box[i][2];
76+
ans = Math.max(ans, f[i]);
77+
}
78+
return ans;
79+
}
80+
}
81+
```
82+
83+
### **C++**
84+
85+
```cpp
86+
class Solution {
87+
public:
88+
int pileBox(vector<vector<int>>& box) {
89+
sort(box.begin(), box.end(), [](const vector<int>& a, const vector<int>& b) {
90+
return a[0] < b[0] || (a[0] == b[0] && b[1] < a[1]);
91+
});
92+
int n = box.size();
93+
int f[n];
94+
memset(f, 0, sizeof(f));
95+
for (int i = 0; i < n; ++i) {
96+
for (int j = 0; j < i; ++j) {
97+
if (box[j][1] < box[i][1] && box[j][2] < box[i][2]) {
98+
f[i] = max(f[i], f[j]);
99+
}
100+
}
101+
f[i] += box[i][2];
102+
}
103+
return *max_element(f, f + n);
104+
}
105+
};
106+
```
107+
108+
### **Go**
109+
110+
```go
111+
func pileBox(box [][]int) (ans int) {
112+
sort.Slice(box, func(i, j int) bool {
113+
a, b := box[i], box[j]
114+
return a[0] < b[0] || (a[0] == b[0] && b[1] < a[1])
115+
})
116+
n := len(box)
117+
f := make([]int, n)
118+
for i := 0; i < n; i++ {
119+
for j := 0; j < i; j++ {
120+
if box[j][1] < box[i][1] && box[j][2] < box[i][2] {
121+
f[i] = max(f[i], f[j])
122+
}
123+
}
124+
f[i] += box[i][2]
125+
ans = max(ans, f[i])
126+
}
127+
return
128+
}
129+
130+
func max(a, b int) int {
131+
if a > b {
132+
return a
133+
}
134+
return b
135+
}
136+
```
42137

138+
### **TypeScript**
139+
140+
```ts
141+
function pileBox(box: number[][]): number {
142+
box.sort((a, b) => (a[0] === b[0] ? b[1] - a[1] : a[0] - b[0]));
143+
const n = box.length;
144+
const f: number[] = new Array(n).fill(0);
145+
let ans: number = 0;
146+
for (let i = 0; i < n; ++i) {
147+
for (let j = 0; j < i; ++j) {
148+
if (box[j][1] < box[i][1] && box[j][2] < box[i][2]) {
149+
f[i] = Math.max(f[i], f[j]);
150+
}
151+
}
152+
f[i] += box[i][2];
153+
ans = Math.max(ans, f[i]);
154+
}
155+
return ans;
156+
}
43157
```
44158

45159
### **...**

‎lcci/08.13.Pile Box/README_EN.md

+104-1
Original file line numberDiff line numberDiff line change
@@ -34,13 +34,116 @@
3434
### **Python3**
3535

3636
```python
37-
37+
class Solution:
38+
def pileBox(self, box: List[List[int]]) -> int:
39+
box.sort(key=lambda x: (x[0], -x[1]))
40+
n = len(box)
41+
f = [0] * n
42+
for i in range(n):
43+
for j in range(i):
44+
if box[j][1] < box[i][1] and box[j][2] < box[i][2]:
45+
f[i] = max(f[i], f[j])
46+
f[i] += box[i][2]
47+
return max(f)
3848
```
3949

4050
### **Java**
4151

4252
```java
53+
class Solution {
54+
public int pileBox(int[][] box) {
55+
Arrays.sort(box, (a, b) -> a[0] == b[0] ? b[1] - a[1] : a[0] - b[0]);
56+
int n = box.length;
57+
int[] f = new int[n];
58+
int ans = 0;
59+
for (int i = 0; i < n; ++i) {
60+
for (int j = 0; j < i; ++j) {
61+
if (box[j][1] < box[i][1] && box[j][2] < box[i][2]) {
62+
f[i] = Math.max(f[i], f[j]);
63+
}
64+
}
65+
f[i] += box[i][2];
66+
ans = Math.max(ans, f[i]);
67+
}
68+
return ans;
69+
}
70+
}
71+
```
72+
73+
### **C++**
74+
75+
```cpp
76+
class Solution {
77+
public:
78+
int pileBox(vector<vector<int>>& box) {
79+
sort(box.begin(), box.end(), [](const vector<int>& a, const vector<int>& b) {
80+
return a[0] < b[0] || (a[0] == b[0] && b[1] < a[1]);
81+
});
82+
int n = box.size();
83+
int f[n];
84+
memset(f, 0, sizeof(f));
85+
for (int i = 0; i < n; ++i) {
86+
for (int j = 0; j < i; ++j) {
87+
if (box[j][1] < box[i][1] && box[j][2] < box[i][2]) {
88+
f[i] = max(f[i], f[j]);
89+
}
90+
}
91+
f[i] += box[i][2];
92+
}
93+
return *max_element(f, f + n);
94+
}
95+
};
96+
```
97+
98+
### **Go**
99+
100+
```go
101+
func pileBox(box [][]int) (ans int) {
102+
sort.Slice(box, func(i, j int) bool {
103+
a, b := box[i], box[j]
104+
return a[0] < b[0] || (a[0] == b[0] && b[1] < a[1])
105+
})
106+
n := len(box)
107+
f := make([]int, n)
108+
for i := 0; i < n; i++ {
109+
for j := 0; j < i; j++ {
110+
if box[j][1] < box[i][1] && box[j][2] < box[i][2] {
111+
f[i] = max(f[i], f[j])
112+
}
113+
}
114+
f[i] += box[i][2]
115+
ans = max(ans, f[i])
116+
}
117+
return
118+
}
119+
120+
func max(a, b int) int {
121+
if a > b {
122+
return a
123+
}
124+
return b
125+
}
126+
```
43127

128+
### **TypeScript**
129+
130+
```ts
131+
function pileBox(box: number[][]): number {
132+
box.sort((a, b) => (a[0] === b[0] ? b[1] - a[1] : a[0] - b[0]));
133+
const n = box.length;
134+
const f: number[] = new Array(n).fill(0);
135+
let ans: number = 0;
136+
for (let i = 0; i < n; ++i) {
137+
for (let j = 0; j < i; ++j) {
138+
if (box[j][1] < box[i][1] && box[j][2] < box[i][2]) {
139+
f[i] = Math.max(f[i], f[j]);
140+
}
141+
}
142+
f[i] += box[i][2];
143+
ans = Math.max(ans, f[i]);
144+
}
145+
return ans;
146+
}
44147
```
45148

46149
### **...**

‎lcci/08.13.Pile Box/Solution.cpp

+20
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
class Solution {
2+
public:
3+
int pileBox(vector<vector<int>>& box) {
4+
sort(box.begin(), box.end(), [](const vector<int>& a, const vector<int>& b) {
5+
return a[0] < b[0] || (a[0] == b[0] && b[1] < a[1]);
6+
});
7+
int n = box.size();
8+
int f[n];
9+
memset(f, 0, sizeof(f));
10+
for (int i = 0; i < n; ++i) {
11+
for (int j = 0; j < i; ++j) {
12+
if (box[j][1] < box[i][1] && box[j][2] < box[i][2]) {
13+
f[i] = max(f[i], f[j]);
14+
}
15+
}
16+
f[i] += box[i][2];
17+
}
18+
return *max_element(f, f + n);
19+
}
20+
};

‎lcci/08.13.Pile Box/Solution.go

+25
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
func pileBox(box [][]int) (ans int) {
2+
sort.Slice(box, func(i, j int) bool {
3+
a, b := box[i], box[j]
4+
return a[0] < b[0] || (a[0] == b[0] && b[1] < a[1])
5+
})
6+
n := len(box)
7+
f := make([]int, n)
8+
for i := 0; i < n; i++ {
9+
for j := 0; j < i; j++ {
10+
if box[j][1] < box[i][1] && box[j][2] < box[i][2] {
11+
f[i] = max(f[i], f[j])
12+
}
13+
}
14+
f[i] += box[i][2]
15+
ans = max(ans, f[i])
16+
}
17+
return
18+
}
19+
20+
func max(a, b int) int {
21+
if a > b {
22+
return a
23+
}
24+
return b
25+
}

‎lcci/08.13.Pile Box/Solution.java

+18
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
class Solution {
2+
public int pileBox(int[][] box) {
3+
Arrays.sort(box, (a, b) -> a[0] == b[0] ? b[1] - a[1] : a[0] - b[0]);
4+
int n = box.length;
5+
int[] f = new int[n];
6+
int ans = 0;
7+
for (int i = 0; i < n; ++i) {
8+
for (int j = 0; j < i; ++j) {
9+
if (box[j][1] < box[i][1] && box[j][2] < box[i][2]) {
10+
f[i] = Math.max(f[i], f[j]);
11+
}
12+
}
13+
f[i] += box[i][2];
14+
ans = Math.max(ans, f[i]);
15+
}
16+
return ans;
17+
}
18+
}

‎lcci/08.13.Pile Box/Solution.py

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
class Solution:
2+
def pileBox(self, box: List[List[int]]) -> int:
3+
box.sort(key=lambda x: (x[0], -x[1]))
4+
n = len(box)
5+
f = [0] * n
6+
for i in range(n):
7+
for j in range(i):
8+
if box[j][1] < box[i][1] and box[j][2] < box[i][2]:
9+
f[i] = max(f[i], f[j])
10+
f[i] += box[i][2]
11+
return max(f)

‎lcci/08.13.Pile Box/Solution.ts

+16
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
function pileBox(box: number[][]): number {
2+
box.sort((a, b) => (a[0] === b[0] ? b[1] - a[1] : a[0] - b[0]));
3+
const n = box.length;
4+
const f: number[] = new Array(n).fill(0);
5+
let ans: number = 0;
6+
for (let i = 0; i < n; ++i) {
7+
for (let j = 0; j < i; ++j) {
8+
if (box[j][1] < box[i][1] && box[j][2] < box[i][2]) {
9+
f[i] = Math.max(f[i], f[j]);
10+
}
11+
}
12+
f[i] += box[i][2];
13+
ans = Math.max(ans, f[i]);
14+
}
15+
return ans;
16+
}

0 commit comments

Comments
 (0)