Skip to content

Commit ab45c7a

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.1231 (doocs#1552)
No.1231.Divide Chocolate
1 parent faa7af7 commit ab45c7a

File tree

7 files changed

+413
-2
lines changed

7 files changed

+413
-2
lines changed

‎solution/1200-1299/1231.Divide Chocolate/README.md

+149-1
Original file line numberDiff line numberDiff line change
@@ -50,22 +50,170 @@
5050

5151
<!-- 这里可写通用的实现逻辑 -->
5252

53+
**方法一：二分查找 + 贪心**
54+
55+
我们注意到，如果我们能吃到一块甜度为 $x$ 的巧克力，那么甜度小于等于 $x$ 的巧克力也都能吃到。这存在着单调性，因此，我们可以使用二分查找，找到最大的满足条件的 $x$。
56+
57+
我们定义二分查找的左边界 $l=0$，右边界 $r=\sum_{i=0}^{n-1} sweetness[i]$。每一次，我们取 $l$ 和 $r$ 的中间值 $mid$，然后判断能否吃到一块甜度为 $mid$ 的巧克力。如果能吃到，那么我们就尝试吃掉甜度更大的巧克力，即令 $l=mid$；否则，我们就尝试吃掉甜度更小的巧克力，即令 $r=mid-1$。在二分查找结束后，我们返回 $l$ 即可。
58+
59+
问题的关键在于，我们如何判断能否吃到一块甜度为 $x$ 的巧克力。我们可以使用贪心的思想，从左到右遍历数组，每次累加当前的甜度，当累加的甜度大于等于 $x$ 时，那么巧克力数 $cnt$ 加 $1$，并将累加的甜度清零。最后判断 $cnt$ 是否大于 $k$ 即可。
60+
61+
时间复杂度 $O(n \times \log \sum_{i=0}^{n-1} sweetness[i])$，空间复杂度 $O(1)$。其中 $n$ 是数组的长度。
62+
5363
<!-- tabs:start -->
5464

5565
### **Python3**
5666

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

5969
```python
60-
70+
class Solution:
71+
def maximizeSweetness(self, sweetness: List[int], k: int) -> int:
72+
def check(x: int) -> bool:
73+
s = cnt = 0
74+
for v in sweetness:
75+
s += v
76+
if s >= x:
77+
s = 0
78+
cnt += 1
79+
return cnt > k
80+
81+
l, r = 0, sum(sweetness)
82+
while l < r:
83+
mid = (l + r + 1) >> 1
84+
if check(mid):
85+
l = mid
86+
else:
87+
r = mid - 1
88+
return l
6189
```
6290

6391
### **Java**
6492

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

6795
```java
96+
class Solution {
97+
public int maximizeSweetness(int[] sweetness, int k) {
98+
int l = 0, r = 0;
99+
for (int v : sweetness) {
100+
r += v;
101+
}
102+
while (l < r) {
103+
int mid = (l + r + 1) >> 1;
104+
if (check(sweetness, mid, k)) {
105+
l = mid;
106+
} else {
107+
r = mid - 1;
108+
}
109+
}
110+
return l;
111+
}
112+
113+
private boolean check(int[] nums, int x, int k) {
114+
int s = 0, cnt = 0;
115+
for (int v : nums) {
116+
s += v;
117+
if (s >= x) {
118+
s = 0;
119+
++cnt;
120+
}
121+
}
122+
return cnt > k;
123+
}
124+
}
125+
```
126+
127+
### **C++**
128+
129+
```cpp
130+
class Solution {
131+
public:
132+
int maximizeSweetness(vector<int>& sweetness, int k) {
133+
int l = 0, r = accumulate(sweetness.begin(), sweetness.end(), 0);
134+
auto check = [&](int x) {
135+
int s = 0, cnt = 0;
136+
for (int v : sweetness) {
137+
s += v;
138+
if (s >= x) {
139+
s = 0;
140+
++cnt;
141+
}
142+
}
143+
return cnt > k;
144+
};
145+
while (l < r) {
146+
int mid = (l + r + 1) >> 1;
147+
if (check(mid)) {
148+
l = mid;
149+
} else {
150+
r = mid - 1;
151+
}
152+
}
153+
return l;
154+
}
155+
};
156+
```
157+
158+
### **Go**
159+
160+
```go
161+
func maximizeSweetness(sweetness []int, k int) int {
162+
l, r := 0, 0
163+
for _, v := range sweetness {
164+
r += v
165+
}
166+
check := func(x int) bool {
167+
s, cnt := 0, 0
168+
for _, v := range sweetness {
169+
s += v
170+
if s >= x {
171+
s = 0
172+
cnt++
173+
}
174+
}
175+
return cnt > k
176+
}
177+
for l < r {
178+
mid := (l + r + 1) >> 1
179+
if check(mid) {
180+
l = mid
181+
} else {
182+
r = mid - 1
183+
}
184+
}
185+
return l
186+
}
187+
```
68188

189+
### **TypeScript**
190+
191+
```ts
192+
function maximizeSweetness(sweetness: number[], k: number): number {
193+
let l = 0;
194+
let r = sweetness.reduce((a, b) => a + b);
195+
const check = (x: number): boolean => {
196+
let s = 0;
197+
let cnt = 0;
198+
for (const v of sweetness) {
199+
s += v;
200+
if (s >= x) {
201+
s = 0;
202+
++cnt;
203+
}
204+
}
205+
return cnt > k;
206+
};
207+
while (l < r) {
208+
const mid = (l + r + 1) >> 1;
209+
if (check(mid)) {
210+
l = mid;
211+
} else {
212+
r = mid - 1;
213+
}
214+
}
215+
return l;
216+
}
69217
```
70218

71219
### **...**

‎solution/1200-1299/1231.Divide Chocolate/README_EN.md

+139-1
Original file line numberDiff line numberDiff line change
@@ -52,13 +52,151 @@
5252
### **Python3**
5353

5454
```python
55-
55+
class Solution:
56+
def maximizeSweetness(self, sweetness: List[int], k: int) -> int:
57+
def check(x: int) -> bool:
58+
s = cnt = 0
59+
for v in sweetness:
60+
s += v
61+
if s >= x:
62+
s = 0
63+
cnt += 1
64+
return cnt > k
65+
66+
l, r = 0, sum(sweetness)
67+
while l < r:
68+
mid = (l + r + 1) >> 1
69+
if check(mid):
70+
l = mid
71+
else:
72+
r = mid - 1
73+
return l
5674
```
5775

5876
### **Java**
5977

6078
```java
79+
class Solution {
80+
public int maximizeSweetness(int[] sweetness, int k) {
81+
int l = 0, r = 0;
82+
for (int v : sweetness) {
83+
r += v;
84+
}
85+
while (l < r) {
86+
int mid = (l + r + 1) >> 1;
87+
if (check(sweetness, mid, k)) {
88+
l = mid;
89+
} else {
90+
r = mid - 1;
91+
}
92+
}
93+
return l;
94+
}
95+
96+
private boolean check(int[] nums, int x, int k) {
97+
int s = 0, cnt = 0;
98+
for (int v : nums) {
99+
s += v;
100+
if (s >= x) {
101+
s = 0;
102+
++cnt;
103+
}
104+
}
105+
return cnt > k;
106+
}
107+
}
108+
```
109+
110+
### **C++**
111+
112+
```cpp
113+
class Solution {
114+
public:
115+
int maximizeSweetness(vector<int>& sweetness, int k) {
116+
int l = 0, r = accumulate(sweetness.begin(), sweetness.end(), 0);
117+
auto check = [&](int x) {
118+
int s = 0, cnt = 0;
119+
for (int v : sweetness) {
120+
s += v;
121+
if (s >= x) {
122+
s = 0;
123+
++cnt;
124+
}
125+
}
126+
return cnt > k;
127+
};
128+
while (l < r) {
129+
int mid = (l + r + 1) >> 1;
130+
if (check(mid)) {
131+
l = mid;
132+
} else {
133+
r = mid - 1;
134+
}
135+
}
136+
return l;
137+
}
138+
};
139+
```
140+
141+
### **Go**
142+
143+
```go
144+
func maximizeSweetness(sweetness []int, k int) int {
145+
l, r := 0, 0
146+
for _, v := range sweetness {
147+
r += v
148+
}
149+
check := func(x int) bool {
150+
s, cnt := 0, 0
151+
for _, v := range sweetness {
152+
s += v
153+
if s >= x {
154+
s = 0
155+
cnt++
156+
}
157+
}
158+
return cnt > k
159+
}
160+
for l < r {
161+
mid := (l + r + 1) >> 1
162+
if check(mid) {
163+
l = mid
164+
} else {
165+
r = mid - 1
166+
}
167+
}
168+
return l
169+
}
170+
```
61171

172+
### **TypeScript**
173+
174+
```ts
175+
function maximizeSweetness(sweetness: number[], k: number): number {
176+
let l = 0;
177+
let r = sweetness.reduce((a, b) => a + b);
178+
const check = (x: number): boolean => {
179+
let s = 0;
180+
let cnt = 0;
181+
for (const v of sweetness) {
182+
s += v;
183+
if (s >= x) {
184+
s = 0;
185+
++cnt;
186+
}
187+
}
188+
return cnt > k;
189+
};
190+
while (l < r) {
191+
const mid = (l + r + 1) >> 1;
192+
if (check(mid)) {
193+
l = mid;
194+
} else {
195+
r = mid - 1;
196+
}
197+
}
198+
return l;
199+
}
62200
```
63201

64202
### **...**

‎solution/1200-1299/1231.Divide Chocolate/Solution.cpp

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
class Solution {
2+
public:
3+
int maximizeSweetness(vector<int>& sweetness, int k) {
4+
int l = 0, r = accumulate(sweetness.begin(), sweetness.end(), 0);
5+
auto check = [&](int x) {
6+
int s = 0, cnt = 0;
7+
for (int v : sweetness) {
8+
s += v;
9+
if (s >= x) {
10+
s = 0;
11+
++cnt;
12+
}
13+
}
14+
return cnt > k;
15+
};
16+
while (l < r) {
17+
int mid = (l + r + 1) >> 1;
18+
if (check(mid)) {
19+
l = mid;
20+
} else {
21+
r = mid - 1;
22+
}
23+
}
24+
return l;
25+
}
26+
};

‎solution/1200-1299/1231.Divide Chocolate/Solution.go

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
func maximizeSweetness(sweetness []int, k int) int {
2+
l, r := 0, 0
3+
for _, v := range sweetness {
4+
r += v
5+
}
6+
check := func(x int) bool {
7+
s, cnt := 0, 0
8+
for _, v := range sweetness {
9+
s += v
10+
if s >= x {
11+
s = 0
12+
cnt++
13+
}
14+
}
15+
return cnt > k
16+
}
17+
for l < r {
18+
mid := (l + r + 1) >> 1
19+
if check(mid) {
20+
l = mid
21+
} else {
22+
r = mid - 1
23+
}
24+
}
25+
return l
26+
}

0 commit comments

Comments
 (0)