Skip to content

Commit 82451a5

Browse files
yanglbmeyanglbme
committedMar 21, 2023
feat: add solutions to lc problems: No.0975,1340
* No.0975.Odd Even Jump * No.1340.Jump Game V
1 parent 381421d commit 82451a5

File tree

12 files changed

+1034
-2
lines changed

12 files changed

+1034
-2
lines changed
 

‎solution/0900-0999/0975.Odd Even Jump/README.md

+150-1
Original file line numberDiff line numberDiff line change
@@ -78,22 +78,171 @@
7878

7979
<!-- 这里可写通用的实现逻辑 -->
8080

81+
**方法一：有序集合 + 记忆化搜索**
82+
83+
我们先利用有序集合，预处理出每个位置能跳到的位置，记录在数组 $g$ 中，其中 $g[i][1]$ 和 $g[i][0]$ 分别表示当前位置是奇数次跳还是偶数次跳时能跳到的位置。如果不能跳到任何位置，那么 $g[i][1]$ 和 $g[i][0]$ 都为 $-1$。
84+
85+
然后利用记忆化搜索，从每个位置出发，且当前是奇数次跳跃，判断是否能跳到数组末尾，如果能，那么结果加一。
86+
87+
时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为数组长度。
88+
8189
<!-- tabs:start -->
8290

8391
### **Python3**
8492

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

8795
```python
88-
96+
from sortedcontainers import SortedDict
97+
98+
99+
class Solution:
100+
def oddEvenJumps(self, arr: List[int]) -> int:
101+
@cache
102+
def dfs(i: int, k: int) -> bool:
103+
if i == n - 1:
104+
return True
105+
if g[i][k] == -1:
106+
return False
107+
return dfs(g[i][k], k ^ 1)
108+
109+
n = len(arr)
110+
g = [[0] * 2 for _ in range(n)]
111+
sd = SortedDict()
112+
for i in range(n - 1, -1, -1):
113+
j = sd.bisect_left(arr[i])
114+
g[i][1] = sd.values()[j] if j < len(sd) else -1
115+
j = sd.bisect_right(arr[i]) - 1
116+
g[i][0] = sd.values()[j] if j >= 0 else -1
117+
sd[arr[i]] = i
118+
return sum(dfs(i, 1) for i in range(n))
89119
```
90120

91121
### **Java**
92122

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

95125
```java
126+
class Solution {
127+
private int n;
128+
private Integer[][] f;
129+
private int[][] g;
130+
131+
public int oddEvenJumps(int[] arr) {
132+
TreeMap<Integer, Integer> tm = new TreeMap<>();
133+
n = arr.length;
134+
f = new Integer[n][2];
135+
g = new int[n][2];
136+
for (int i = n - 1; i >= 0; --i) {
137+
var hi = tm.ceilingEntry(arr[i]);
138+
g[i][1] = hi == null ? -1 : hi.getValue();
139+
var lo = tm.floorEntry(arr[i]);
140+
g[i][0] = lo == null ? -1 : lo.getValue();
141+
tm.put(arr[i], i);
142+
}
143+
int ans = 0;
144+
for (int i = 0; i < n; ++i) {
145+
ans += dfs(i, 1);
146+
}
147+
return ans;
148+
}
149+
150+
private int dfs(int i, int k) {
151+
if (i == n - 1) {
152+
return 1;
153+
}
154+
if (g[i][k] == -1) {
155+
return 0;
156+
}
157+
if (f[i][k] != null) {
158+
return f[i][k];
159+
}
160+
return f[i][k] = dfs(g[i][k], k ^ 1);
161+
}
162+
}
163+
```
164+
165+
### **C++**
166+
167+
```cpp
168+
class Solution {
169+
public:
170+
int oddEvenJumps(vector<int>& arr) {
171+
int n = arr.size();
172+
map<int, int> d;
173+
int f[n][2];
174+
int g[n][2];
175+
memset(f, 0, sizeof(f));
176+
for (int i = n - 1; ~i; --i) {
177+
auto it = d.lower_bound(arr[i]);
178+
g[i][1] = it == d.end() ? -1 : it->second;
179+
it = d.upper_bound(arr[i]);
180+
g[i][0] = it == d.begin() ? -1 : prev(it)->second;
181+
d[arr[i]] = i;
182+
}
183+
function<int(int, int)> dfs = [&](int i, int k) -> int {
184+
if (i == n - 1) {
185+
return 1;
186+
}
187+
if (g[i][k] == -1) {
188+
return 0;
189+
}
190+
if (f[i][k] != 0) {
191+
return f[i][k];
192+
}
193+
return f[i][k] = dfs(g[i][k], k ^ 1);
194+
};
195+
int ans = 0;
196+
for (int i = 0; i < n; ++i) {
197+
ans += dfs(i, 1);
198+
}
199+
return ans;
200+
}
201+
};
202+
```
96203
204+
### **Go**
205+
206+
```go
207+
func oddEvenJumps(arr []int) (ans int) {
208+
n := len(arr)
209+
rbt := redblacktree.NewWithIntComparator()
210+
f := make([][2]int, n)
211+
g := make([][2]int, n)
212+
for i := n - 1; i >= 0; i-- {
213+
if v, ok := rbt.Ceiling(arr[i]); ok {
214+
g[i][1] = v.Value.(int)
215+
} else {
216+
g[i][1] = -1
217+
}
218+
if v, ok := rbt.Floor(arr[i]); ok {
219+
g[i][0] = v.Value.(int)
220+
} else {
221+
g[i][0] = -1
222+
}
223+
rbt.Put(arr[i], i)
224+
}
225+
var dfs func(int, int) int
226+
dfs = func(i, k int) int {
227+
if i == n-1 {
228+
return 1
229+
}
230+
if g[i][k] == -1 {
231+
return 0
232+
}
233+
if f[i][k] != 0 {
234+
return f[i][k]
235+
}
236+
f[i][k] = dfs(g[i][k], k^1)
237+
return f[i][k]
238+
}
239+
for i := 0; i < n; i++ {
240+
if dfs(i, 1) == 1 {
241+
ans++
242+
}
243+
}
244+
return
245+
}
97246
```
98247

99248
### **...**

‎solution/0900-0999/0975.Odd Even Jump/README_EN.md

+142-1
Original file line numberDiff line numberDiff line change
@@ -76,13 +76,154 @@ number of jumps.
7676
### **Python3**
7777

7878
```python
79-
79+
from sortedcontainers import SortedDict
80+
81+
82+
class Solution:
83+
def oddEvenJumps(self, arr: List[int]) -> int:
84+
@cache
85+
def dfs(i: int, k: int) -> bool:
86+
if i == n - 1:
87+
return True
88+
if g[i][k] == -1:
89+
return False
90+
return dfs(g[i][k], k ^ 1)
91+
92+
n = len(arr)
93+
g = [[0] * 2 for _ in range(n)]
94+
sd = SortedDict()
95+
for i in range(n - 1, -1, -1):
96+
j = sd.bisect_left(arr[i])
97+
g[i][1] = sd.values()[j] if j < len(sd) else -1
98+
j = sd.bisect_right(arr[i]) - 1
99+
g[i][0] = sd.values()[j] if j >= 0 else -1
100+
sd[arr[i]] = i
101+
return sum(dfs(i, 1) for i in range(n))
80102
```
81103

82104
### **Java**
83105

84106
```java
107+
class Solution {
108+
private int n;
109+
private Integer[][] f;
110+
private int[][] g;
111+
112+
public int oddEvenJumps(int[] arr) {
113+
TreeMap<Integer, Integer> tm = new TreeMap<>();
114+
n = arr.length;
115+
f = new Integer[n][2];
116+
g = new int[n][2];
117+
for (int i = n - 1; i >= 0; --i) {
118+
var hi = tm.ceilingEntry(arr[i]);
119+
g[i][1] = hi == null ? -1 : hi.getValue();
120+
var lo = tm.floorEntry(arr[i]);
121+
g[i][0] = lo == null ? -1 : lo.getValue();
122+
tm.put(arr[i], i);
123+
}
124+
int ans = 0;
125+
for (int i = 0; i < n; ++i) {
126+
ans += dfs(i, 1);
127+
}
128+
return ans;
129+
}
130+
131+
private int dfs(int i, int k) {
132+
if (i == n - 1) {
133+
return 1;
134+
}
135+
if (g[i][k] == -1) {
136+
return 0;
137+
}
138+
if (f[i][k] != null) {
139+
return f[i][k];
140+
}
141+
return f[i][k] = dfs(g[i][k], k ^ 1);
142+
}
143+
}
144+
```
145+
146+
### **C++**
147+
148+
```cpp
149+
class Solution {
150+
public:
151+
int oddEvenJumps(vector<int>& arr) {
152+
int n = arr.size();
153+
map<int, int> d;
154+
int f[n][2];
155+
int g[n][2];
156+
memset(f, 0, sizeof(f));
157+
for (int i = n - 1; ~i; --i) {
158+
auto it = d.lower_bound(arr[i]);
159+
g[i][1] = it == d.end() ? -1 : it->second;
160+
it = d.upper_bound(arr[i]);
161+
g[i][0] = it == d.begin() ? -1 : prev(it)->second;
162+
d[arr[i]] = i;
163+
}
164+
function<int(int, int)> dfs = [&](int i, int k) -> int {
165+
if (i == n - 1) {
166+
return 1;
167+
}
168+
if (g[i][k] == -1) {
169+
return 0;
170+
}
171+
if (f[i][k] != 0) {
172+
return f[i][k];
173+
}
174+
return f[i][k] = dfs(g[i][k], k ^ 1);
175+
};
176+
int ans = 0;
177+
for (int i = 0; i < n; ++i) {
178+
ans += dfs(i, 1);
179+
}
180+
return ans;
181+
}
182+
};
183+
```
85184
185+
### **Go**
186+
187+
```go
188+
func oddEvenJumps(arr []int) (ans int) {
189+
n := len(arr)
190+
rbt := redblacktree.NewWithIntComparator()
191+
f := make([][2]int, n)
192+
g := make([][2]int, n)
193+
for i := n - 1; i >= 0; i-- {
194+
if v, ok := rbt.Ceiling(arr[i]); ok {
195+
g[i][1] = v.Value.(int)
196+
} else {
197+
g[i][1] = -1
198+
}
199+
if v, ok := rbt.Floor(arr[i]); ok {
200+
g[i][0] = v.Value.(int)
201+
} else {
202+
g[i][0] = -1
203+
}
204+
rbt.Put(arr[i], i)
205+
}
206+
var dfs func(int, int) int
207+
dfs = func(i, k int) int {
208+
if i == n-1 {
209+
return 1
210+
}
211+
if g[i][k] == -1 {
212+
return 0
213+
}
214+
if f[i][k] != 0 {
215+
return f[i][k]
216+
}
217+
f[i][k] = dfs(g[i][k], k^1)
218+
return f[i][k]
219+
}
220+
for i := 0; i < n; i++ {
221+
if dfs(i, 1) == 1 {
222+
ans++
223+
}
224+
}
225+
return
226+
}
86227
```
87228

88229
### **...**

‎solution/0900-0999/0975.Odd Even Jump/Solution.cpp

+34
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
class Solution {
2+
public:
3+
int oddEvenJumps(vector<int>& arr) {
4+
int n = arr.size();
5+
map<int, int> d;
6+
int f[n][2];
7+
int g[n][2];
8+
memset(f, 0, sizeof(f));
9+
for (int i = n - 1; ~i; --i) {
10+
auto it = d.lower_bound(arr[i]);
11+
g[i][1] = it == d.end() ? -1 : it->second;
12+
it = d.upper_bound(arr[i]);
13+
g[i][0] = it == d.begin() ? -1 : prev(it)->second;
14+
d[arr[i]] = i;
15+
}
16+
function<int(int, int)> dfs = [&](int i, int k) -> int {
17+
if (i == n - 1) {
18+
return 1;
19+
}
20+
if (g[i][k] == -1) {
21+
return 0;
22+
}
23+
if (f[i][k] != 0) {
24+
return f[i][k];
25+
}
26+
return f[i][k] = dfs(g[i][k], k ^ 1);
27+
};
28+
int ans = 0;
29+
for (int i = 0; i < n; ++i) {
30+
ans += dfs(i, 1);
31+
}
32+
return ans;
33+
}
34+
};

0 commit comments

Comments
 (0)
Please sign in to comment.