Skip to content

Commit 62f7cd4

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lcp problems: No.50,51 (doocs#1451)
* No.50.宝石补给 * No.51.烹饪料理
1 parent a503d6c commit 62f7cd4

12 files changed

+470
-2
lines changed

‎lcp/LCP 50. 宝石补给/README.md

+93-1
Original file line numberDiff line numberDiff line change
@@ -57,22 +57,114 @@
5757

5858
<!-- 这里可写通用的实现逻辑 -->
5959

60+
**方法一：模拟**
61+
62+
我们直接模拟宝石的赠送过程，最后返回最大值和最小值的差值即可。
63+
64+
时间复杂度 $O(m + n)$，其中 $m$ 和 $n$ 分别是数组 `gem` 和 `operations` 的长度。空间复杂度 $O(1)$。
65+
6066
<!-- tabs:start -->
6167

6268
### **Python3**
6369

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

6672
```python
67-
73+
class Solution:
74+
def giveGem(self, gem: List[int], operations: List[List[int]]) -> int:
75+
for x, y in operations:
76+
v = gem[x] >> 1
77+
gem[y] += v
78+
gem[x] -= v
79+
return max(gem) - min(gem)
6880
```
6981

7082
### **Java**
7183

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

7486
```java
87+
class Solution {
88+
public int giveGem(int[] gem, int[][] operations) {
89+
for (var op : operations) {
90+
int x = op[0], y = op[1];
91+
int v = gem[x] >> 1;
92+
gem[y] += v;
93+
gem[x] -= v;
94+
}
95+
int mx = 0, mi = 1 << 30;
96+
for (int x : gem) {
97+
mx = Math.max(mx, x);
98+
mi = Math.min(mi, x);
99+
}
100+
return mx - mi;
101+
}
102+
}
103+
```
104+
105+
### **C++**
106+
107+
```cpp
108+
class Solution {
109+
public:
110+
int giveGem(vector<int>& gem, vector<vector<int>>& operations) {
111+
for (auto& op : operations) {
112+
int x = op[0], y = op[1];
113+
int v = gem[x] >> 1;
114+
gem[y] += v;
115+
gem[x] -= v;
116+
}
117+
int mx = *max_element(gem.begin(), gem.end());
118+
int mi = *min_element(gem.begin(), gem.end());
119+
return mx - mi;
120+
}
121+
};
122+
```
123+
124+
### **Go**
125+
126+
```go
127+
func giveGem(gem []int, operations [][]int) int {
128+
for _, op := range operations {
129+
x, y := op[0], op[1]
130+
v := gem[x] >> 1
131+
gem[y] += v
132+
gem[x] -= v
133+
}
134+
mx, mi := 0, 1<<30
135+
for _, x := range gem {
136+
mx = max(mx, x)
137+
mi = min(mi, x)
138+
}
139+
return mx - mi
140+
}
141+
142+
func max(a, b int) int {
143+
if a > b {
144+
return a
145+
}
146+
return b
147+
}
148+
149+
func min(a, b int) int {
150+
if a < b {
151+
return a
152+
}
153+
return b
154+
}
155+
```
75156

157+
### **TypeScript**
158+
159+
```ts
160+
function giveGem(gem: number[], operations: number[][]): number {
161+
for (const [x, y] of operations) {
162+
const v = gem[x] >> 1;
163+
gem[y] += v;
164+
gem[x] -= v;
165+
}
166+
return Math.max(...gem) - Math.min(...gem);
167+
}
76168
```
77169

78170
### **...**

‎lcp/LCP 50. 宝石补给/Solution.cpp

+14
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
class Solution {
2+
public:
3+
int giveGem(vector<int>& gem, vector<vector<int>>& operations) {
4+
for (auto& op : operations) {
5+
int x = op[0], y = op[1];
6+
int v = gem[x] >> 1;
7+
gem[y] += v;
8+
gem[x] -= v;
9+
}
10+
int mx = *max_element(gem.begin(), gem.end());
11+
int mi = *min_element(gem.begin(), gem.end());
12+
return mx - mi;
13+
}
14+
};

‎lcp/LCP 50. 宝石补给/Solution.go

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
func giveGem(gem []int, operations [][]int) int {
2+
for _, op := range operations {
3+
x, y := op[0], op[1]
4+
v := gem[x] >> 1
5+
gem[y] += v
6+
gem[x] -= v
7+
}
8+
mx, mi := 0, 1<<30
9+
for _, x := range gem {
10+
mx = max(mx, x)
11+
mi = min(mi, x)
12+
}
13+
return mx - mi
14+
}
15+
16+
func max(a, b int) int {
17+
if a > b {
18+
return a
19+
}
20+
return b
21+
}
22+
23+
func min(a, b int) int {
24+
if a < b {
25+
return a
26+
}
27+
return b
28+
}

‎lcp/LCP 50. 宝石补给/Solution.java

+16
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
class Solution {
2+
public int giveGem(int[] gem, int[][] operations) {
3+
for (var op : operations) {
4+
int x = op[0], y = op[1];
5+
int v = gem[x] >> 1;
6+
gem[y] += v;
7+
gem[x] -= v;
8+
}
9+
int mx = 0, mi = 1 << 30;
10+
for (int x : gem) {
11+
mx = Math.max(mx, x);
12+
mi = Math.min(mi, x);
13+
}
14+
return mx - mi;
15+
}
16+
}

‎lcp/LCP 50. 宝石补给/Solution.py

+7
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,7 @@
1+
class Solution:
2+
def giveGem(self, gem: List[int], operations: List[List[int]]) -> int:
3+
for x, y in operations:
4+
v = gem[x] >> 1
5+
gem[y] += v
6+
gem[x] -= v
7+
return max(gem) - min(gem)

‎lcp/LCP 50. 宝石补给/Solution.ts

+8
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,8 @@
1+
function giveGem(gem: number[], operations: number[][]): number {
2+
for (const [x, y] of operations) {
3+
const v = gem[x] >> 1;
4+
gem[y] += v;
5+
gem[x] -= v;
6+
}
7+
return Math.max(...gem) - Math.min(...gem);
8+
}

‎lcp/LCP 51. 烹饪料理/README.md

+165-1
Original file line numberDiff line numberDiff line change
@@ -47,22 +47,186 @@
4747

4848
<!-- 这里可写通用的实现逻辑 -->
4949

50+
**方法一：二进制枚举**
51+
52+
我们注意到，料理的数量 $n$ 不超过 $8$，因此，我们可以使用二进制枚举的方法枚举所有的料理方案。
53+
54+
每种料理都有两种选择：制作或者不制作。因此，我们可以使用一个长度为 $8$ 的二进制数来表示一种方案，其中第 $i$ 位为 $1$ 表示制作第 $i$ 道料理，为 $0$ 表示不制作第 $i$ 道料理。
55+
56+
我们在 $[0, 2^n)$ 的范围内枚举所有料理方案，对于每种方案，我们计算其美味度和饱腹感，如果饱腹感不小于 $limit$，并且食材数量足够制作这些料理，同时其美味度大于当前答案，我们就更新答案。
57+
58+
枚举结束后，我们就可以得到最大的美味度。
59+
60+
时间复杂度 $(2^n \times n)$，其中 $n$ 是料理的数量。我们需要枚举所有的料理方案，对于每种方案，我们需要 $O(n)$ 的时间计算其美味度和饱腹感，因此总时间复杂度为 $O(2^n \times n)$。空间复杂度 $O(1)$。
61+
5062
<!-- tabs:start -->
5163

5264
### **Python3**
5365

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

5668
```python
57-
69+
class Solution:
70+
def perfectMenu(
71+
self,
72+
materials: List[int],
73+
cookbooks: List[List[int]],
74+
attribute: List[List[int]],
75+
limit: int,
76+
) -> int:
77+
n = len(cookbooks)
78+
ans = -1
79+
for mask in range(1 << n):
80+
a = b = 0
81+
cnt = [0] * 5
82+
for i in range(n):
83+
if mask >> i & 1:
84+
x, y = attribute[i]
85+
a += x
86+
b += y
87+
for j, v in enumerate(cookbooks[i]):
88+
cnt[j] += v
89+
if b >= limit and ans < a and all(c <= d for c, d in zip(cnt, materials)):
90+
ans = a
91+
return ans
5892
```
5993

6094
### **Java**
6195

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

6498
```java
99+
class Solution {
100+
public int perfectMenu(int[] materials, int[][] cookbooks, int[][] attribute, int limit) {
101+
int n = cookbooks.length;
102+
int ans = -1;
103+
for (int mask = 0; mask < 1 << n; ++mask) {
104+
int a = 0, b = 0;
105+
int[] cnt = new int[5];
106+
for (int i = 0; i < n; ++i) {
107+
if ((mask >> i & 1) == 1) {
108+
int x = attribute[i][0];
109+
int y = attribute[i][1];
110+
a += x;
111+
b += y;
112+
for (int j = 0; j < cookbooks[i].length; ++j) {
113+
cnt[j] += cookbooks[i][j];
114+
}
115+
}
116+
}
117+
boolean ok = true;
118+
for (int i = 0; i < 5 && ok; ++i) {
119+
ok = cnt[i] <= materials[i];
120+
}
121+
if (b >= limit && ans < a && ok) {
122+
ans = a;
123+
}
124+
}
125+
return ans;
126+
}
127+
}
128+
```
129+
130+
### **C++**
131+
132+
```cpp
133+
class Solution {
134+
public:
135+
int perfectMenu(vector<int>& materials, vector<vector<int>>& cookbooks, vector<vector<int>>& attribute, int limit) {
136+
int n = cookbooks.size();
137+
int ans = -1;
138+
for (int mask = 0; mask < 1 << n; ++mask) {
139+
int a = 0, b = 0;
140+
vector<int> cnt(5);
141+
for (int i = 0; i < n; ++i) {
142+
if (mask >> i & 1) {
143+
int x = attribute[i][0];
144+
int y = attribute[i][1];
145+
a += x;
146+
b += y;
147+
for (int j = 0; j < cookbooks[i].size(); ++j) {
148+
cnt[j] += cookbooks[i][j];
149+
}
150+
}
151+
bool ok = true;
152+
for (int i = 0; i < 5 && ok; ++i) {
153+
ok = cnt[i] <= materials[i];
154+
}
155+
if (b >= limit && ans < a && ok) {
156+
ans = a;
157+
}
158+
}
159+
}
160+
return ans;
161+
}
162+
};
163+
```
164+
165+
### **Go**
166+
167+
```go
168+
func perfectMenu(materials []int, cookbooks [][]int, attribute [][]int, limit int) int {
169+
n := len(cookbooks)
170+
ans := -1
171+
for mask := 0; mask < 1<<n; mask++ {
172+
a, b := 0, 0
173+
cnt := make([]int, 5)
174+
for i := 0; i < n; i++ {
175+
if mask>>i&1 == 1 {
176+
x, y := attribute[i][0], attribute[i][1]
177+
a += x
178+
b += y
179+
for j, v := range cookbooks[i] {
180+
cnt[j] += v
181+
}
182+
}
183+
ok := true
184+
for i := 0; i < 5 && ok; i++ {
185+
ok = cnt[i] <= materials[i]
186+
}
187+
if ok && b >= limit && ans < a {
188+
ans = a
189+
}
190+
}
191+
}
192+
return ans
193+
}
194+
```
65195

196+
### **TypeScript**
197+
198+
```ts
199+
function perfectMenu(
200+
materials: number[],
201+
cookbooks: number[][],
202+
attribute: number[][],
203+
limit: number,
204+
): number {
205+
const n = cookbooks.length;
206+
let ans = -1;
207+
for (let mask = 0; mask < 1 << n; ++mask) {
208+
let [a, b] = [0, 0];
209+
const cnt: number[] = Array(5).fill(0);
210+
for (let i = 0; i < n; ++i) {
211+
if (((mask >> i) & 1) === 1) {
212+
const [x, y] = attribute[i];
213+
a += x;
214+
b += y;
215+
for (let j = 0; j < cookbooks[i].length; ++j) {
216+
cnt[j] += cookbooks[i][j];
217+
}
218+
}
219+
let ok = true;
220+
for (let i = 0; i < 5 && ok; ++i) {
221+
ok = cnt[i] <= materials[i];
222+
}
223+
if (b >= limit && ans < a && ok) {
224+
ans = a;
225+
}
226+
}
227+
}
228+
return ans;
229+
}
66230
```
67231

68232
### **...**

0 commit comments

Comments
 (0)