Skip to content

Commit 88aeedc

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0808
No.0808.Soup Servings
1 parent 67d2f81 commit 88aeedc

File tree

7 files changed

+316
-3
lines changed

7 files changed

+316
-3
lines changed

‎solution/0600-0699/0609.Find Duplicate File in System/Solution.py

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,6 @@ def findDuplicate(self, paths: List[str]) -> List[List[str]]:
55
ps = p.split()
66
for f in ps[1:]:
77
i = f.find('(')
8-
name, content = f[:i], f[i + 1: -1]
8+
name, content = f[:i], f[i + 1 : -1]
99
d[content].append(ps[0] + '/' + name)
1010
return [v for v in d.values() if len(v) > 1]

‎solution/0800-0899/0808.Soup Servings/README.md

Lines changed: 126 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -53,22 +53,147 @@
5353

5454
<!-- 这里可写通用的实现逻辑 -->
5555

56+
**方法一：记忆化搜索**
57+
58+
在这道题中，由于每次操作都是 $25$ 的倍数，因此，我们可以将每 `25ml` 的汤视为一份。这样就能将数据规模缩小到 $\left \lceil \frac{n}{25} \right \rceil $。
59+
60+
我们设计一个函数 $dfs(i, j)$，表示当前剩余 $i$ 份汤 $A$ 和 $j$ 份汤 $B$ 的结果概率。
61+
62+
当 $i \leq 0 \cap j \leq 0$ 时，表示两种汤都分配完了，此时应该返回 $0.5$；当 $i \leq 0$ 时，表示汤 $A$ 先分配完了，此时应该返回 $1$；当 $j \leq 0$ 时，表示汤 $B$ 先分配完了，此时应该返回 $0$。
63+
64+
接下来，对于每一次操作，我们都有四种选择，即：
65+
66+
- 从 $i$ 份汤 $A$ 中取出 $4$ 份，从 $j$ 份汤 $B$ 中取出 $0$ 份；
67+
- 从 $i$ 份汤 $A$ 中取出 $3$ 份，从 $j$ 份汤 $B$ 中取出 $1$ 份；
68+
- 从 $i$ 份汤 $A$ 中取出 $2$ 份，从 $j$ 份汤 $B$ 中取出 $2$ 份；
69+
- 从 $i$ 份汤 $A$ 中取出 $1$ 份，从 $j$ 份汤 $B$ 中取出 $3$ 份；
70+
71+
每一种选择的概率都是 $0.25$，因此，我们可以得到：
72+
73+
$$
74+
dfs(i, j) = 0.25 \times (dfs(i - 4, j) + dfs(i - 3, j - 1) + dfs(i - 2, j - 2) + dfs(i - 1, j - 3))
75+
$$
76+
77+
记忆化搜索即可。
78+
79+
另外，我们发现在 $n=4800$ 时，结果为 $0.999994994426$，而题目要求的精度为 $10^{-5}$，并且随着 $n$ 的增大，结果越来越接近 $1$，因此，当 $n \ge 4800$ 时，直接返回 $1$ 即可。
80+
81+
时间复杂度 $O(C^2)$，空间复杂度 $O(C^2)$。本题中 $C=200$。
82+
5683
<!-- tabs:start -->
5784

5885
### **Python3**
5986

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

6289
```python
63-
90+
class Solution:
91+
def soupServings(self, n: int) -> float:
92+
@cache
93+
def dfs(i, j):
94+
if i <= 0 and j <= 0:
95+
return 0.5
96+
if i <= 0:
97+
return 1
98+
if j <= 0:
99+
return 0
100+
return 0.25 * (
101+
dfs(i - 4, j)
102+
+ dfs(i - 3, j - 1)
103+
+ dfs(i - 2, j - 2)
104+
+ dfs(i - 1, j - 3)
105+
)
106+
107+
return 1 if n > 4800 else dfs((n + 24) // 25, (n + 24) // 25)
64108
```
65109

66110
### **Java**
67111

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

70114
```java
115+
class Solution {
116+
private double[][] f = new double[200][200];
117+
118+
public double soupServings(int n) {
119+
return n > 4800 ? 1 : dfs((n + 24) / 25, (n + 24) / 25);
120+
}
121+
122+
private double dfs(int i, int j) {
123+
if (i <= 0 && j <= 0) {
124+
return 0.5;
125+
}
126+
if (i <= 0) {
127+
return 1.0;
128+
}
129+
if (j <= 0) {
130+
return 0;
131+
}
132+
if (f[i][j] > 0) {
133+
return f[i][j];
134+
}
135+
double ans = 0.25 * (dfs(i - 4, j) + dfs(i - 3, j - 1) + dfs(i - 2, j - 2) + dfs(i - 1, j - 3));
136+
f[i][j] = ans;
137+
return ans;
138+
}
139+
}
140+
```
141+
142+
### **C++**
143+
144+
```cpp
145+
class Solution {
146+
public:
147+
double f[200][200];
148+
149+
double soupServings(int n) {
150+
memset(f, 0, sizeof f);
151+
return n > 4800 ? 1 : dfs((n + 24) / 25, (n + 24) / 25);
152+
}
153+
154+
double dfs(int i, int j) {
155+
if (i <= 0 && j <= 0) return 0.5;
156+
if (i <= 0) return 1;
157+
if (j <= 0) return 0;
158+
if (f[i][j] > 0) return f[i][j];
159+
double ans = 0.25 * (dfs(i - 4, j) + dfs(i - 3, j - 1) + dfs(i - 2, j - 2) + dfs(i - 1, j - 3));
160+
f[i][j] = ans;
161+
return ans;
162+
}
163+
};
164+
```
71165
166+
### **Go**
167+
168+
```go
169+
func soupServings(n int) float64 {
170+
if n > 4800 {
171+
return 1
172+
}
173+
f := make([][]float64, 200)
174+
for i := range f {
175+
f[i] = make([]float64, 200)
176+
}
177+
var dfs func(i, j int) float64
178+
dfs = func(i, j int) float64 {
179+
if i <= 0 && j <= 0 {
180+
return 0.5
181+
}
182+
if i <= 0 {
183+
return 1.0
184+
}
185+
if j <= 0 {
186+
return 0
187+
}
188+
if f[i][j] > 0 {
189+
return f[i][j]
190+
}
191+
ans := 0.25 * (dfs(i-4, j) + dfs(i-3, j-1) + dfs(i-2, j-2) + dfs(i-1, j-3))
192+
f[i][j] = ans
193+
return ans
194+
}
195+
return dfs((n+24)/25, (n+24)/25)
196+
}
72197
```
73198

74199
### **...**

‎solution/0800-0899/0808.Soup Servings/README_EN.md

Lines changed: 99 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -52,13 +52,111 @@ So the total probability of A becoming empty first plus half the probability tha
5252
### **Python3**
5353

5454
```python
55-
55+
class Solution:
56+
def soupServings(self, n: int) -> float:
57+
@cache
58+
def dfs(i, j):
59+
if i <= 0 and j <= 0:
60+
return 0.5
61+
if i <= 0:
62+
return 1
63+
if j <= 0:
64+
return 0
65+
return 0.25 * (
66+
dfs(i - 4, j)
67+
+ dfs(i - 3, j - 1)
68+
+ dfs(i - 2, j - 2)
69+
+ dfs(i - 1, j - 3)
70+
)
71+
72+
return 1 if n > 4800 else dfs((n + 24) // 25, (n + 24) // 25)
5673
```
5774

5875
### **Java**
5976

6077
```java
78+
class Solution {
79+
private double[][] f = new double[200][200];
80+
81+
public double soupServings(int n) {
82+
return n > 4800 ? 1 : dfs((n + 24) / 25, (n + 24) / 25);
83+
}
84+
85+
private double dfs(int i, int j) {
86+
if (i <= 0 && j <= 0) {
87+
return 0.5;
88+
}
89+
if (i <= 0) {
90+
return 1.0;
91+
}
92+
if (j <= 0) {
93+
return 0;
94+
}
95+
if (f[i][j] > 0) {
96+
return f[i][j];
97+
}
98+
double ans = 0.25 * (dfs(i - 4, j) + dfs(i - 3, j - 1) + dfs(i - 2, j - 2) + dfs(i - 1, j - 3));
99+
f[i][j] = ans;
100+
return ans;
101+
}
102+
}
103+
```
104+
105+
### **C++**
106+
107+
```cpp
108+
class Solution {
109+
public:
110+
double f[200][200];
111+
112+
double soupServings(int n) {
113+
memset(f, 0, sizeof f);
114+
return n > 4800 ? 1 : dfs((n + 24) / 25, (n + 24) / 25);
115+
}
116+
117+
double dfs(int i, int j) {
118+
if (i <= 0 && j <= 0) return 0.5;
119+
if (i <= 0) return 1;
120+
if (j <= 0) return 0;
121+
if (f[i][j] > 0) return f[i][j];
122+
double ans = 0.25 * (dfs(i - 4, j) + dfs(i - 3, j - 1) + dfs(i - 2, j - 2) + dfs(i - 1, j - 3));
123+
f[i][j] = ans;
124+
return ans;
125+
}
126+
};
127+
```
61128
129+
### **Go**
130+
131+
```go
132+
func soupServings(n int) float64 {
133+
if n > 4800 {
134+
return 1
135+
}
136+
f := make([][]float64, 200)
137+
for i := range f {
138+
f[i] = make([]float64, 200)
139+
}
140+
var dfs func(i, j int) float64
141+
dfs = func(i, j int) float64 {
142+
if i <= 0 && j <= 0 {
143+
return 0.5
144+
}
145+
if i <= 0 {
146+
return 1.0
147+
}
148+
if j <= 0 {
149+
return 0
150+
}
151+
if f[i][j] > 0 {
152+
return f[i][j]
153+
}
154+
ans := 0.25 * (dfs(i-4, j) + dfs(i-3, j-1) + dfs(i-2, j-2) + dfs(i-1, j-3))
155+
f[i][j] = ans
156+
return ans
157+
}
158+
return dfs((n+24)/25, (n+24)/25)
159+
}
62160
```
63161

64162
### **...**

‎solution/0800-0899/0808.Soup Servings/Solution.cpp

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
class Solution {
2+
public:
3+
double f[200][200];
4+
5+
double soupServings(int n) {
6+
memset(f, 0, sizeof f);
7+
return n > 4800 ? 1 : dfs((n + 24) / 25, (n + 24) / 25);
8+
}
9+
10+
double dfs(int i, int j) {
11+
if (i <= 0 && j <= 0) return 0.5;
12+
if (i <= 0) return 1;
13+
if (j <= 0) return 0;
14+
if (f[i][j] > 0) return f[i][j];
15+
double ans = 0.25 * (dfs(i - 4, j) + dfs(i - 3, j - 1) + dfs(i - 2, j - 2) + dfs(i - 1, j - 3));
16+
f[i][j] = ans;
17+
return ans;
18+
}
19+
};

‎solution/0800-0899/0808.Soup Servings/Solution.go

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
func soupServings(n int) float64 {
2+
if n > 4800 {
3+
return 1
4+
}
5+
f := make([][]float64, 200)
6+
for i := range f {
7+
f[i] = make([]float64, 200)
8+
}
9+
var dfs func(i, j int) float64
10+
dfs = func(i, j int) float64 {
11+
if i <= 0 && j <= 0 {
12+
return 0.5
13+
}
14+
if i <= 0 {
15+
return 1.0
16+
}
17+
if j <= 0 {
18+
return 0
19+
}
20+
if f[i][j] > 0 {
21+
return f[i][j]
22+
}
23+
ans := 0.25 * (dfs(i-4, j) + dfs(i-3, j-1) + dfs(i-2, j-2) + dfs(i-1, j-3))
24+
f[i][j] = ans
25+
return ans
26+
}
27+
return dfs((n+24)/25, (n+24)/25)
28+
}

‎solution/0800-0899/0808.Soup Servings/Solution.java

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
class Solution {
2+
private double[][] f = new double[200][200];
3+
4+
public double soupServings(int n) {
5+
return n > 4800 ? 1 : dfs((n + 24) / 25, (n + 24) / 25);
6+
}
7+
8+
private double dfs(int i, int j) {
9+
if (i <= 0 && j <= 0) {
10+
return 0.5;
11+
}
12+
if (i <= 0) {
13+
return 1.0;
14+
}
15+
if (j <= 0) {
16+
return 0;
17+
}
18+
if (f[i][j] > 0) {
19+
return f[i][j];
20+
}
21+
double ans = 0.25 * (dfs(i - 4, j) + dfs(i - 3, j - 1) + dfs(i - 2, j - 2) + dfs(i - 1, j - 3));
22+
f[i][j] = ans;
23+
return ans;
24+
}
25+
}

‎solution/0800-0899/0808.Soup Servings/Solution.py

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
class Solution:
2+
def soupServings(self, n: int) -> float:
3+
@cache
4+
def dfs(i, j):
5+
if i <= 0 and j <= 0:
6+
return 0.5
7+
if i <= 0:
8+
return 1
9+
if j <= 0:
10+
return 0
11+
return 0.25 * (
12+
dfs(i - 4, j)
13+
+ dfs(i - 3, j - 1)
14+
+ dfs(i - 2, j - 2)
15+
+ dfs(i - 1, j - 3)
16+
)
17+
18+
return 1 if n > 4800 else dfs((n + 24) // 25, (n + 24) // 25)

0 commit comments

Comments
 (0)