Skip to content

Commit 6599ec8

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

File tree

7 files changed

+373
-2
lines changed

7 files changed

+373
-2
lines changed

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

Lines changed: 141 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -55,22 +55,162 @@
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]$，因此我们可以得到状态转移方程：$f[i][j] = \max(f[i - 1][j], f[i - 2][j - 1] + nums[i - 1])$。
71+
72+
最后返回 $f[m][n]$ 即可。
73+
74+
时间复杂度 $O(n^2)$，空间复杂度 $O(n^2)$。其中 $n$ 是数组 $slices$ 的长度。
75+
5876
<!-- tabs:start -->
5977

6078
### **Python3**
6179

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

6482
```python
65-
83+
class Solution:
84+
def maxSizeSlices(self, slices: List[int]) -> int:
85+
def g(nums: List[int]) -> int:
86+
m = len(nums)
87+
f = [[0] * (n + 1) for _ in range(m + 1)]
88+
for i in range(1, m + 1):
89+
for j in range(1, n + 1):
90+
f[i][j] = max(f[i - 1][j], (f[i - 2][j - 1]
91+
if i >= 2 else 0) + nums[i - 1])
92+
return f[m][n]
93+
94+
n = len(slices) // 3
95+
a, b = g(slices[:-1]), g(slices[1:])
96+
return max(a, b)
6697
```
6798

6899
### **Java**
69100

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

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

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

76216
### **...**

‎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)