Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 6599ec8

Browse files
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
### **...**
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+
};
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+
}
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+
}
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)

AltStyle によって変換されたページ (->オリジナル) /