Skip to content

Commit 86a34a1

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1345
No.1345.Jump Game IV
1 parent 860cae0 commit 86a34a1

File tree

6 files changed

+438
-2
lines changed

6 files changed

+438
-2
lines changed

‎solution/1300-1399/1345.Jump Game IV/README.md

+149-1
Original file line numberDiff line numberDiff line change
@@ -75,15 +75,163 @@
7575
<!-- 这里可写当前语言的特殊实现逻辑 -->
7676

7777
```python
78-
78+
class Solution:
79+
def minJumps(self, arr: List[int]) -> int:
80+
idx = defaultdict(list)
81+
for i, v in enumerate(arr):
82+
idx[v].append(i)
83+
q = deque([(0, 0)])
84+
vis = {0}
85+
while q:
86+
i, step = q.popleft()
87+
if i == len(arr) - 1:
88+
return step
89+
v = arr[i]
90+
step += 1
91+
for j in idx[v]:
92+
if j not in vis:
93+
vis.add(j)
94+
q.append((j, step))
95+
del idx[v]
96+
if i + 1 < len(arr) and (i + 1) not in vis:
97+
vis.add(i + 1)
98+
q.append((i + 1, step))
99+
if i - 1 >= 0 and (i - 1) not in vis:
100+
vis.add(i - 1)
101+
q.append((i - 1, step))
79102
```
80103

81104
### **Java**
82105

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

85108
```java
109+
class Solution {
110+
public int minJumps(int[] arr) {
111+
Map<Integer, List<Integer>> idx = new HashMap<>();
112+
int n = arr.length;
113+
for (int i = 0; i < n; ++i) {
114+
idx.computeIfAbsent(arr[i], k -> new ArrayList<>()).add(i);
115+
}
116+
Deque<int[]> q = new LinkedList<>();
117+
Set<Integer> vis = new HashSet<>();
118+
vis.add(0);
119+
q.offer(new int[]{0, 0});
120+
while (!q.isEmpty()) {
121+
int[] e = q.pollFirst();
122+
int i = e[0], step = e[1];
123+
if (i == n - 1) {
124+
return step;
125+
}
126+
int v = arr[i];
127+
++step;
128+
for (int j : idx.getOrDefault(v, new ArrayList<>())) {
129+
if (!vis.contains(j)) {
130+
vis.add(j);
131+
q.offer(new int[]{j, step});
132+
}
133+
}
134+
idx.remove(v);
135+
if (i + 1 < n && !vis.contains(i + 1)) {
136+
vis.add(i + 1);
137+
q.offer(new int[]{i + 1, step});
138+
}
139+
if (i - 1 >= 0 && !vis.contains(i - 1)) {
140+
vis.add(i - 1);
141+
q.offer(new int[]{i - 1, step});
142+
}
143+
}
144+
return -1;
145+
}
146+
}
147+
```
148+
149+
### **C++**
150+
151+
```cpp
152+
class Solution {
153+
public:
154+
int minJumps(vector<int>& arr) {
155+
unordered_map<int, vector<int>> idx;
156+
int n = arr.size();
157+
for (int i = 0; i < n; ++i) idx[arr[i]].push_back(i);
158+
queue<pair<int, int>> q;
159+
q.emplace(0, 0);
160+
unordered_set<int> vis;
161+
vis.insert(0);
162+
while (!q.empty())
163+
{
164+
auto e = q.front();
165+
q.pop();
166+
int i = e.first, step = e.second;
167+
if (i == n - 1) return step;
168+
int v = arr[i];
169+
++step;
170+
if (idx.count(v))
171+
{
172+
for (int j : idx[v])
173+
{
174+
if (!vis.count(j))
175+
{
176+
vis.insert(j);
177+
q.emplace(j, step);
178+
}
179+
}
180+
idx.erase(v);
181+
}
182+
if (i + 1 < n && !vis.count(i + 1))
183+
{
184+
vis.insert(i + 1);
185+
q.emplace(i + 1, step);
186+
}
187+
if (i - 1 >= 0 && !vis.count(i - 1))
188+
{
189+
vis.insert(i - 1);
190+
q.emplace(i - 1, step);
191+
}
192+
}
193+
return -1;
194+
}
195+
};
196+
```
86197
198+
### **Go**
199+
200+
```go
201+
func minJumps(arr []int) int {
202+
idx := map[int][]int{}
203+
for i, v := range arr {
204+
idx[v] = append(idx[v], i)
205+
}
206+
vis := map[int]bool{0: true}
207+
type pair struct{ idx, step int }
208+
q := []pair{{0, 0}}
209+
for len(q) > 0 {
210+
e := q[0]
211+
q = q[1:]
212+
i, step := e.idx, e.step
213+
if i == len(arr)-1 {
214+
return step
215+
}
216+
step++
217+
for _, j := range idx[arr[i]] {
218+
if !vis[j] {
219+
vis[j] = true
220+
q = append(q, pair{j, step})
221+
}
222+
}
223+
delete(idx, arr[i])
224+
if i+1 < len(arr) && !vis[i+1] {
225+
vis[i+1] = true
226+
q = append(q, pair{i + 1, step})
227+
}
228+
if i-1 >= 0 && !vis[i-1] {
229+
vis[i-1] = true
230+
q = append(q, pair{i - 1, step})
231+
}
232+
}
233+
return -1
234+
}
87235
```
88236

89237
### **...**

‎solution/1300-1399/1345.Jump Game IV/README_EN.md

+149-1
Original file line numberDiff line numberDiff line change
@@ -72,13 +72,161 @@
7272
### **Python3**
7373

7474
```python
75-
75+
class Solution:
76+
def minJumps(self, arr: List[int]) -> int:
77+
idx = defaultdict(list)
78+
for i, v in enumerate(arr):
79+
idx[v].append(i)
80+
q = deque([(0, 0)])
81+
vis = {0}
82+
while q:
83+
i, step = q.popleft()
84+
if i == len(arr) - 1:
85+
return step
86+
v = arr[i]
87+
step += 1
88+
for j in idx[v]:
89+
if j not in vis:
90+
vis.add(j)
91+
q.append((j, step))
92+
del idx[v]
93+
if i + 1 < len(arr) and (i + 1) not in vis:
94+
vis.add(i + 1)
95+
q.append((i + 1, step))
96+
if i - 1 >= 0 and (i - 1) not in vis:
97+
vis.add(i - 1)
98+
q.append((i - 1, step))
7699
```
77100

78101
### **Java**
79102

80103
```java
104+
class Solution {
105+
public int minJumps(int[] arr) {
106+
Map<Integer, List<Integer>> idx = new HashMap<>();
107+
int n = arr.length;
108+
for (int i = 0; i < n; ++i) {
109+
idx.computeIfAbsent(arr[i], k -> new ArrayList<>()).add(i);
110+
}
111+
Deque<int[]> q = new LinkedList<>();
112+
Set<Integer> vis = new HashSet<>();
113+
vis.add(0);
114+
q.offer(new int[]{0, 0});
115+
while (!q.isEmpty()) {
116+
int[] e = q.pollFirst();
117+
int i = e[0], step = e[1];
118+
if (i == n - 1) {
119+
return step;
120+
}
121+
int v = arr[i];
122+
++step;
123+
for (int j : idx.getOrDefault(v, new ArrayList<>())) {
124+
if (!vis.contains(j)) {
125+
vis.add(j);
126+
q.offer(new int[]{j, step});
127+
}
128+
}
129+
idx.remove(v);
130+
if (i + 1 < n && !vis.contains(i + 1)) {
131+
vis.add(i + 1);
132+
q.offer(new int[]{i + 1, step});
133+
}
134+
if (i - 1 >= 0 && !vis.contains(i - 1)) {
135+
vis.add(i - 1);
136+
q.offer(new int[]{i - 1, step});
137+
}
138+
}
139+
return -1;
140+
}
141+
}
142+
```
143+
144+
### **C++**
145+
146+
```cpp
147+
class Solution {
148+
public:
149+
int minJumps(vector<int>& arr) {
150+
unordered_map<int, vector<int>> idx;
151+
int n = arr.size();
152+
for (int i = 0; i < n; ++i) idx[arr[i]].push_back(i);
153+
queue<pair<int, int>> q;
154+
q.emplace(0, 0);
155+
unordered_set<int> vis;
156+
vis.insert(0);
157+
while (!q.empty())
158+
{
159+
auto e = q.front();
160+
q.pop();
161+
int i = e.first, step = e.second;
162+
if (i == n - 1) return step;
163+
int v = arr[i];
164+
++step;
165+
if (idx.count(v))
166+
{
167+
for (int j : idx[v])
168+
{
169+
if (!vis.count(j))
170+
{
171+
vis.insert(j);
172+
q.emplace(j, step);
173+
}
174+
}
175+
idx.erase(v);
176+
}
177+
if (i + 1 < n && !vis.count(i + 1))
178+
{
179+
vis.insert(i + 1);
180+
q.emplace(i + 1, step);
181+
}
182+
if (i - 1 >= 0 && !vis.count(i - 1))
183+
{
184+
vis.insert(i - 1);
185+
q.emplace(i - 1, step);
186+
}
187+
}
188+
return -1;
189+
}
190+
};
191+
```
81192
193+
### **Go**
194+
195+
```go
196+
func minJumps(arr []int) int {
197+
idx := map[int][]int{}
198+
for i, v := range arr {
199+
idx[v] = append(idx[v], i)
200+
}
201+
vis := map[int]bool{0: true}
202+
type pair struct{ idx, step int }
203+
q := []pair{{0, 0}}
204+
for len(q) > 0 {
205+
e := q[0]
206+
q = q[1:]
207+
i, step := e.idx, e.step
208+
if i == len(arr)-1 {
209+
return step
210+
}
211+
step++
212+
for _, j := range idx[arr[i]] {
213+
if !vis[j] {
214+
vis[j] = true
215+
q = append(q, pair{j, step})
216+
}
217+
}
218+
delete(idx, arr[i])
219+
if i+1 < len(arr) && !vis[i+1] {
220+
vis[i+1] = true
221+
q = append(q, pair{i + 1, step})
222+
}
223+
if i-1 >= 0 && !vis[i-1] {
224+
vis[i-1] = true
225+
q = append(q, pair{i - 1, step})
226+
}
227+
}
228+
return -1
229+
}
82230
```
83231

84232
### **...**

‎solution/1300-1399/1345.Jump Game IV/Solution.cpp

+44
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,44 @@
1+
class Solution {
2+
public:
3+
int minJumps(vector<int>& arr) {
4+
unordered_map<int, vector<int>> idx;
5+
int n = arr.size();
6+
for (int i = 0; i < n; ++i) idx[arr[i]].push_back(i);
7+
queue<pair<int, int>> q;
8+
q.emplace(0, 0);
9+
unordered_set<int> vis;
10+
vis.insert(0);
11+
while (!q.empty())
12+
{
13+
auto e = q.front();
14+
q.pop();
15+
int i = e.first, step = e.second;
16+
if (i == n - 1) return step;
17+
int v = arr[i];
18+
++step;
19+
if (idx.count(v))
20+
{
21+
for (int j : idx[v])
22+
{
23+
if (!vis.count(j))
24+
{
25+
vis.insert(j);
26+
q.emplace(j, step);
27+
}
28+
}
29+
idx.erase(v);
30+
}
31+
if (i + 1 < n && !vis.count(i + 1))
32+
{
33+
vis.insert(i + 1);
34+
q.emplace(i + 1, step);
35+
}
36+
if (i - 1 >= 0 && !vis.count(i - 1))
37+
{
38+
vis.insert(i - 1);
39+
q.emplace(i - 1, step);
40+
}
41+
}
42+
return -1;
43+
}
44+
};

0 commit comments

Comments
 (0)