Skip to content

Commit 3aaa9c5

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1553
No.1553.Minimum Number of Days to Eat N Oranges
1 parent b9acdb4 commit 3aaa9c5

File tree

6 files changed

+203
-6
lines changed

6 files changed

+203
-6
lines changed

‎solution/1500-1599/1553.Minimum Number of Days to Eat N Oranges/README.md

Lines changed: 75 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -67,22 +67,96 @@
6767

6868
<!-- 这里可写通用的实现逻辑 -->
6969

70+
**方法一：记忆化搜索**
71+
7072
<!-- tabs:start -->
7173

7274
### **Python3**
7375

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

7678
```python
77-
79+
class Solution:
80+
def minDays(self, n: int) -> int:
81+
@cache
82+
def dfs(n):
83+
if n < 2:
84+
return n
85+
return 1 + min(n % 2 + dfs(n // 2), n % 3 + dfs(n // 3))
86+
87+
return dfs(n)
7888
```
7989

8090
### **Java**
8191

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

8494
```java
95+
class Solution {
96+
private Map<Integer, Integer> f = new HashMap<>();
97+
98+
public int minDays(int n) {
99+
return dfs(n);
100+
}
101+
102+
private int dfs(int n) {
103+
if (n < 2) {
104+
return n;
105+
}
106+
if (f.containsKey(n)) {
107+
return f.get(n);
108+
}
109+
int res = 1 + Math.min(n % 2 + dfs(n / 2), n % 3 + dfs(n / 3));
110+
f.put(n, res);
111+
return res;
112+
}
113+
}
114+
```
115+
116+
### **C++**
117+
118+
```cpp
119+
class Solution {
120+
public:
121+
unordered_map<int, int> f;
122+
123+
int minDays(int n) {
124+
return dfs(n);
125+
}
126+
127+
int dfs(int n) {
128+
if (n < 2) return n;
129+
if (f.count(n)) return f[n];
130+
int res = 1 + min(n % 2 + dfs(n / 2), n % 3 + dfs(n / 3));
131+
f[n] = res;
132+
return res;
133+
}
134+
};
135+
```
85136
137+
### **Go**
138+
139+
```go
140+
func minDays(n int) int {
141+
f := map[int]int{0: 0, 1: 1}
142+
var dfs func(int) int
143+
dfs = func(n int) int {
144+
if v, ok := f[n]; ok {
145+
return v
146+
}
147+
res := 1 + min(n%2+dfs(n/2), n%3+dfs(n/3))
148+
f[n] = res
149+
return res
150+
}
151+
return dfs(n)
152+
}
153+
154+
func min(a, b int) int {
155+
if a < b {
156+
return a
157+
}
158+
return b
159+
}
86160
```
87161

88162
### **...**

‎solution/1500-1599/1553.Minimum Number of Days to Eat N Oranges/README_EN.md

Lines changed: 73 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -56,13 +56,85 @@ You need at least 3 days to eat the 6 oranges.
5656
### **Python3**
5757

5858
```python
59-
59+
class Solution:
60+
def minDays(self, n: int) -> int:
61+
@cache
62+
def dfs(n):
63+
if n < 2:
64+
return n
65+
return 1 + min(n % 2 + dfs(n // 2), n % 3 + dfs(n // 3))
66+
67+
return dfs(n)
6068
```
6169

6270
### **Java**
6371

6472
```java
73+
class Solution {
74+
private Map<Integer, Integer> f = new HashMap<>();
75+
76+
public int minDays(int n) {
77+
return dfs(n);
78+
}
79+
80+
private int dfs(int n) {
81+
if (n < 2) {
82+
return n;
83+
}
84+
if (f.containsKey(n)) {
85+
return f.get(n);
86+
}
87+
int res = 1 + Math.min(n % 2 + dfs(n / 2), n % 3 + dfs(n / 3));
88+
f.put(n, res);
89+
return res;
90+
}
91+
}
92+
```
93+
94+
### **C++**
95+
96+
```cpp
97+
class Solution {
98+
public:
99+
unordered_map<int, int> f;
100+
101+
int minDays(int n) {
102+
return dfs(n);
103+
}
104+
105+
int dfs(int n) {
106+
if (n < 2) return n;
107+
if (f.count(n)) return f[n];
108+
int res = 1 + min(n % 2 + dfs(n / 2), n % 3 + dfs(n / 3));
109+
f[n] = res;
110+
return res;
111+
}
112+
};
113+
```
65114
115+
### **Go**
116+
117+
```go
118+
func minDays(n int) int {
119+
f := map[int]int{0: 0, 1: 1}
120+
var dfs func(int) int
121+
dfs = func(n int) int {
122+
if v, ok := f[n]; ok {
123+
return v
124+
}
125+
res := 1 + min(n%2+dfs(n/2), n%3+dfs(n/3))
126+
f[n] = res
127+
return res
128+
}
129+
return dfs(n)
130+
}
131+
132+
func min(a, b int) int {
133+
if a < b {
134+
return a
135+
}
136+
return b
137+
}
66138
```
67139

68140
### **...**

‎solution/1500-1599/1553.Minimum Number of Days to Eat N Oranges/Solution.cpp

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
class Solution {
2+
public:
3+
unordered_map<int, int> f;
4+
5+
int minDays(int n) {
6+
return dfs(n);
7+
}
8+
9+
int dfs(int n) {
10+
if (n < 2) return n;
11+
if (f.count(n)) return f[n];
12+
int res = 1 + min(n % 2 + dfs(n / 2), n % 3 + dfs(n / 3));
13+
f[n] = res;
14+
return res;
15+
}
16+
};

‎solution/1500-1599/1553.Minimum Number of Days to Eat N Oranges/Solution.go

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
func minDays(n int) int {
2+
f := map[int]int{0: 0, 1: 1}
3+
var dfs func(int) int
4+
dfs = func(n int) int {
5+
if v, ok := f[n]; ok {
6+
return v
7+
}
8+
res := 1 + min(n%2+dfs(n/2), n%3+dfs(n/3))
9+
f[n] = res
10+
return res
11+
}
12+
return dfs(n)
13+
}
14+
15+
func min(a, b int) int {
16+
if a < b {
17+
return a
18+
}
19+
return b
20+
}

‎solution/1500-1599/1553.Minimum Number of Days to Eat N Oranges/Solution.java

Lines changed: 10 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,19 @@
11
class Solution {
2-
private Map<Integer, Integer> map = new HashMap<>();
2+
private Map<Integer, Integer> f = new HashMap<>();
33

44
public int minDays(int n) {
5+
return dfs(n);
6+
}
7+
8+
private int dfs(int n) {
59
if (n < 2) {
610
return n;
711
}
8-
if (!map.containsKey(n)) {
9-
map.put(n, Math.min(minDays(n / 2) + 1 + n % 2, minDays(n / 3) + 1 + n % 3));
12+
if (f.containsKey(n)) {
13+
return f.get(n);
1014
}
11-
return map.get(n);
15+
int res = 1 + Math.min(n % 2 + dfs(n / 2), n % 3 + dfs(n / 3));
16+
f.put(n, res);
17+
return res;
1218
}
1319
}

‎solution/1500-1599/1553.Minimum Number of Days to Eat N Oranges/Solution.py

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,9 @@
1+
class Solution:
2+
def minDays(self, n: int) -> int:
3+
@cache
4+
def dfs(n):
5+
if n < 2:
6+
return n
7+
return 1 + min(n % 2 + dfs(n // 2), n % 3 + dfs(n // 3))
8+
9+
return dfs(n)

0 commit comments

Comments
 (0)