Skip to content

Commit 6da6314

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1388
No.1388 Pizza With 3n Slices
1 parent f44b99b commit 6da6314

File tree

7 files changed

+377
-2
lines changed

7 files changed

+377
-2
lines changed

‎solution/1300-1399/1388.Pizza With 3n Slices/README.md

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

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

58+
**方法一：动态规划**
59+
60+
我们可以将这个问题转化为：在一个环形数组中，选择其中 $n$ 个不相邻的数，使得这 $n$ 个数的和最大。
61+
62+
环形数组中，如果选择了第一个数，那么最后一个数就不能选择，如果选择了最后一个数，那么第一个数就不能选择，因此我们可以将环形数组拆成两个数组，一个是去掉第一个数的，一个是去掉最后一个数的，然后分别求解这两个数组的最大值，最后取两个最大值中的较大值即可。
63+
64+
我们用一个函数 $g(nums)$，表示在数组 $nums$ 中选择 $n$ 个不相邻的数，使得这 $n$ 个数的和最大，那么我们的目标就是求 $g(slices)$ 和 $g(slices[1:])$ 中的较大值。
65+
66+
函数 $g(nums)$ 的求解方法如下：
67+
68+
我们记数组 $nums$ 的长度为 $m$，定义 $f[i][j]$ 表示在数组 $nums$ 的前 $i$ 个数中选择 $j$ 个不相邻的数的最大和。
69+
70+
考虑 $f[i][j]$，如果我们不选择第 $i$ 个数，那么 $f[i][j] = f[i - 1][j]$，如果我们选择第 $i$ 个数，那么 $f[i][j] = f[i - 2][j - 1] + nums[i - 1]$，因此我们可以得到状态转移方程：
71+
72+
$$
73+
f[i][j] = \max(f[i - 1][j], f[i - 2][j - 1] + nums[i - 1])
74+
$$
75+
76+
最后返回 $f[m][n]$ 即可。
77+
78+
时间复杂度 $O(n^2)$，空间复杂度 $O(n^2)$。其中 $n$ 是数组 $slices$ 的长度。
79+
5880
<!-- tabs:start -->
5981

6082
### **Python3**
6183

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

6486
```python
65-
87+
class Solution:
88+
def maxSizeSlices(self, slices: List[int]) -> int:
89+
def g(nums: List[int]) -> int:
90+
m = len(nums)
91+
f = [[0] * (n + 1) for _ in range(m + 1)]
92+
for i in range(1, m + 1):
93+
for j in range(1, n + 1):
94+
f[i][j] = max(f[i - 1][j], (f[i - 2][j - 1]
95+
if i >= 2 else 0) + nums[i - 1])
96+
return f[m][n]
97+
98+
n = len(slices) // 3
99+
a, b = g(slices[:-1]), g(slices[1:])
100+
return max(a, b)
66101
```
67102

68103
### **Java**
69104

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

72107
```java
108+
class Solution {
109+
private int n;
110+
111+
public int maxSizeSlices(int[] slices) {
112+
n = slices.length / 3;
113+
int[] nums = new int[slices.length - 1];
114+
System.arraycopy(slices, 1, nums, 0, nums.length);
115+
int a = g(nums);
116+
System.arraycopy(slices, 0, nums, 0, nums.length);
117+
int b = g(nums);
118+
return Math.max(a, b);
119+
}
120+
121+
private int g(int[] nums) {
122+
int m = nums.length;
123+
int[][] f = new int[m + 1][n + 1];
124+
for (int i = 1; i <= m; ++i) {
125+
for (int j = 1; j <= n; ++j) {
126+
f[i][j] = Math.max(f[i - 1][j], (i >= 2 ? f[i - 2][j - 1] : 0) + nums[i - 1]);
127+
}
128+
}
129+
return f[m][n];
130+
}
131+
}
132+
```
133+
134+
### **C++**
135+
136+
```cpp
137+
class Solution {
138+
public:
139+
int maxSizeSlices(vector<int>& slices) {
140+
int n = slices.size() / 3;
141+
auto g = [&](vector<int>& nums) -> int {
142+
int m = nums.size();
143+
int f[m + 1][n + 1];
144+
memset(f, 0, sizeof f);
145+
for (int i = 1; i <= m; ++i) {
146+
for (int j = 1; j <= n; ++j) {
147+
f[i][j] = max(f[i - 1][j], (i >= 2 ? f[i - 2][j - 1] : 0) + nums[i - 1]);
148+
}
149+
}
150+
return f[m][n];
151+
};
152+
vector<int> nums(slices.begin(), slices.end() - 1);
153+
int a = g(nums);
154+
nums = vector<int>(slices.begin() + 1, slices.end());
155+
int b = g(nums);
156+
return max(a, b);
157+
}
158+
};
159+
```
160+
161+
### **Go**
162+
163+
```go
164+
func maxSizeSlices(slices []int) int {
165+
n := len(slices) / 3
166+
g := func(nums []int) int {
167+
m := len(nums)
168+
f := make([][]int, m+1)
169+
for i := range f {
170+
f[i] = make([]int, n+1)
171+
}
172+
for i := 1; i <= m; i++ {
173+
for j := 1; j <= n; j++ {
174+
f[i][j] = max(f[i-1][j], nums[i-1])
175+
if i >= 2 {
176+
f[i][j] = max(f[i][j], f[i-2][j-1]+nums[i-1])
177+
}
178+
}
179+
}
180+
return f[m][n]
181+
}
182+
a, b := g(slices[:len(slices)-1]), g(slices[1:])
183+
return max(a, b)
184+
}
185+
186+
func max(a, b int) int {
187+
if a > b {
188+
return a
189+
}
190+
return b
191+
}
192+
```
73193

194+
### **TypeScript**
195+
196+
```ts
197+
function maxSizeSlices(slices: number[]): number {
198+
const n = Math.floor(slices.length / 3);
199+
const g = (nums: number[]): number => {
200+
const m = nums.length;
201+
const f: number[][] = Array(m + 1)
202+
.fill(0)
203+
.map(() => Array(n + 1).fill(0));
204+
for (let i = 1; i <= m; ++i) {
205+
for (let j = 1; j <= n; ++j) {
206+
f[i][j] = Math.max(
207+
f[i - 1][j],
208+
(i > 1 ? f[i - 2][j - 1] : 0) + nums[i - 1],
209+
);
210+
}
211+
}
212+
return f[m][n];
213+
};
214+
const a = g(slices.slice(0, -1));
215+
const b = g(slices.slice(1));
216+
return Math.max(a, b);
217+
}
74218
```
75219

76220
### **...**

‎solution/1300-1399/1388.Pizza With 3n Slices/README_EN.md

Lines changed: 123 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -48,13 +48,135 @@
4848
### **Python3**
4949

5050
```python
51-
51+
class Solution:
52+
def maxSizeSlices(self, slices: List[int]) -> int:
53+
def g(nums: List[int]) -> int:
54+
m = len(nums)
55+
f = [[0] * (n + 1) for _ in range(m + 1)]
56+
for i in range(1, m + 1):
57+
for j in range(1, n + 1):
58+
f[i][j] = max(f[i - 1][j], (f[i - 2][j - 1]
59+
if i >= 2 else 0) + nums[i - 1])
60+
return f[m][n]
61+
62+
n = len(slices) // 3
63+
a, b = g(slices[:-1]), g(slices[1:])
64+
return max(a, b)
5265
```
5366

5467
### **Java**
5568

5669
```java
70+
class Solution {
71+
private int n;
72+
73+
public int maxSizeSlices(int[] slices) {
74+
n = slices.length / 3;
75+
int[] nums = new int[slices.length - 1];
76+
System.arraycopy(slices, 1, nums, 0, nums.length);
77+
int a = g(nums);
78+
System.arraycopy(slices, 0, nums, 0, nums.length);
79+
int b = g(nums);
80+
return Math.max(a, b);
81+
}
82+
83+
private int g(int[] nums) {
84+
int m = nums.length;
85+
int[][] f = new int[m + 1][n + 1];
86+
for (int i = 1; i <= m; ++i) {
87+
for (int j = 1; j <= n; ++j) {
88+
f[i][j] = Math.max(f[i - 1][j], (i >= 2 ? f[i - 2][j - 1] : 0) + nums[i - 1]);
89+
}
90+
}
91+
return f[m][n];
92+
}
93+
}
94+
```
95+
96+
### **C++**
97+
98+
```cpp
99+
class Solution {
100+
public:
101+
int maxSizeSlices(vector<int>& slices) {
102+
int n = slices.size() / 3;
103+
auto g = [&](vector<int>& nums) -> int {
104+
int m = nums.size();
105+
int f[m + 1][n + 1];
106+
memset(f, 0, sizeof f);
107+
for (int i = 1; i <= m; ++i) {
108+
for (int j = 1; j <= n; ++j) {
109+
f[i][j] = max(f[i - 1][j], (i >= 2 ? f[i - 2][j - 1] : 0) + nums[i - 1]);
110+
}
111+
}
112+
return f[m][n];
113+
};
114+
vector<int> nums(slices.begin(), slices.end() - 1);
115+
int a = g(nums);
116+
nums = vector<int>(slices.begin() + 1, slices.end());
117+
int b = g(nums);
118+
return max(a, b);
119+
}
120+
};
121+
```
122+
123+
### **Go**
124+
125+
```go
126+
func maxSizeSlices(slices []int) int {
127+
n := len(slices) / 3
128+
g := func(nums []int) int {
129+
m := len(nums)
130+
f := make([][]int, m+1)
131+
for i := range f {
132+
f[i] = make([]int, n+1)
133+
}
134+
for i := 1; i <= m; i++ {
135+
for j := 1; j <= n; j++ {
136+
f[i][j] = max(f[i-1][j], nums[i-1])
137+
if i >= 2 {
138+
f[i][j] = max(f[i][j], f[i-2][j-1]+nums[i-1])
139+
}
140+
}
141+
}
142+
return f[m][n]
143+
}
144+
a, b := g(slices[:len(slices)-1]), g(slices[1:])
145+
return max(a, b)
146+
}
147+
148+
func max(a, b int) int {
149+
if a > b {
150+
return a
151+
}
152+
return b
153+
}
154+
```
57155

156+
### **TypeScript**
157+
158+
```ts
159+
function maxSizeSlices(slices: number[]): number {
160+
const n = Math.floor(slices.length / 3);
161+
const g = (nums: number[]): number => {
162+
const m = nums.length;
163+
const f: number[][] = Array(m + 1)
164+
.fill(0)
165+
.map(() => Array(n + 1).fill(0));
166+
for (let i = 1; i <= m; ++i) {
167+
for (let j = 1; j <= n; ++j) {
168+
f[i][j] = Math.max(
169+
f[i - 1][j],
170+
(i > 1 ? f[i - 2][j - 1] : 0) + nums[i - 1],
171+
);
172+
}
173+
}
174+
return f[m][n];
175+
};
176+
const a = g(slices.slice(0, -1));
177+
const b = g(slices.slice(1));
178+
return Math.max(a, b);
179+
}
58180
```
59181

60182
### **...**

‎solution/1300-1399/1388.Pizza With 3n Slices/Solution.cpp

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
class Solution {
2+
public:
3+
int maxSizeSlices(vector<int>& slices) {
4+
int n = slices.size() / 3;
5+
auto g = [&](vector<int>& nums) -> int {
6+
int m = nums.size();
7+
int f[m + 1][n + 1];
8+
memset(f, 0, sizeof f);
9+
for (int i = 1; i <= m; ++i) {
10+
for (int j = 1; j <= n; ++j) {
11+
f[i][j] = max(f[i - 1][j], (i >= 2 ? f[i - 2][j - 1] : 0) + nums[i - 1]);
12+
}
13+
}
14+
return f[m][n];
15+
};
16+
vector<int> nums(slices.begin(), slices.end() - 1);
17+
int a = g(nums);
18+
nums = vector<int>(slices.begin() + 1, slices.end());
19+
int b = g(nums);
20+
return max(a, b);
21+
}
22+
};

‎solution/1300-1399/1388.Pizza With 3n Slices/Solution.go

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
func maxSizeSlices(slices []int) int {
2+
n := len(slices) / 3
3+
g := func(nums []int) int {
4+
m := len(nums)
5+
f := make([][]int, m+1)
6+
for i := range f {
7+
f[i] = make([]int, n+1)
8+
}
9+
for i := 1; i <= m; i++ {
10+
for j := 1; j <= n; j++ {
11+
f[i][j] = max(f[i-1][j], nums[i-1])
12+
if i >= 2 {
13+
f[i][j] = max(f[i][j], f[i-2][j-1]+nums[i-1])
14+
}
15+
}
16+
}
17+
return f[m][n]
18+
}
19+
a, b := g(slices[:len(slices)-1]), g(slices[1:])
20+
return max(a, b)
21+
}
22+
23+
func max(a, b int) int {
24+
if a > b {
25+
return a
26+
}
27+
return b
28+
}

‎solution/1300-1399/1388.Pizza With 3n Slices/Solution.java

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
class Solution {
2+
private int n;
3+
4+
public int maxSizeSlices(int[] slices) {
5+
n = slices.length / 3;
6+
int[] nums = new int[slices.length - 1];
7+
System.arraycopy(slices, 1, nums, 0, nums.length);
8+
int a = g(nums);
9+
System.arraycopy(slices, 0, nums, 0, nums.length);
10+
int b = g(nums);
11+
return Math.max(a, b);
12+
}
13+
14+
private int g(int[] nums) {
15+
int m = nums.length;
16+
int[][] f = new int[m + 1][n + 1];
17+
for (int i = 1; i <= m; ++i) {
18+
for (int j = 1; j <= n; ++j) {
19+
f[i][j] = Math.max(f[i - 1][j], (i >= 2 ? f[i - 2][j - 1] : 0) + nums[i - 1]);
20+
}
21+
}
22+
return f[m][n];
23+
}
24+
}

‎solution/1300-1399/1388.Pizza With 3n Slices/Solution.py

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
class Solution:
2+
def maxSizeSlices(self, slices: List[int]) -> int:
3+
def g(nums: List[int]) -> int:
4+
m = len(nums)
5+
f = [[0] * (n + 1) for _ in range(m + 1)]
6+
for i in range(1, m + 1):
7+
for j in range(1, n + 1):
8+
f[i][j] = max(f[i - 1][j], (f[i - 2][j - 1]
9+
if i >= 2 else 0) + nums[i - 1])
10+
return f[m][n]
11+
12+
n = len(slices) // 3
13+
a, b = g(slices[:-1]), g(slices[1:])
14+
return max(a, b)

0 commit comments

Comments
 (0)