@@ -85,69 +85,59 @@ tags:
8585``` python
8686class Solution :
8787 def minJumps (self arr : List[int ]) -> int :
88- idx = defaultdict(list )
89- for i, v in enumerate (arr):
90- idx[v ].append(i)
91- q = deque([( 0 , 0 ) ])
88+ g = defaultdict(list )
89+ for i, x in enumerate (arr):
90+ g[x ].append(i)
91+ q = deque([0 ])
9292 vis = {0 }
93- while q:
94- i, step = q.popleft()
95- if i == len (arr) - 1 :
96- return step
97- v = arr[i]
98- step += 1
99- for j in idx[v]:
100- if j not in vis:
101- vis.add(j)
102- q.append((j, step))
103- del idx[v]
104- if i + 1 < len (arr) and (i + 1 ) not in vis:
105- vis.add(i + 1 )
106- q.append((i + 1 , step))
107- if i - 1 >= 0 and (i - 1 ) not in vis:
108- vis.add(i - 1 )
109- q.append((i - 1 , step))
93+ ans = 0
94+ while 1 :
95+ for _ in range (len (q)):
96+ i = q.popleft()
97+ if i == len (arr) - 1 :
98+ return ans
99+ for j in (i + 1 , i - 1 , * g.pop(arr[i], [])):
100+ if 0 <= j < len (arr) and j not in vis:
101+ q.append(j)
102+ vis.add(j)
103+ ans += 1
110104```
111105
112106#### Java
113107
114108``` java
115109class Solution {
116110 public int minJumps (int [] arr ) {
117- Map<Integer , List<Integer > > idx = new HashMap<> ();
111+ Map<Integer , List<Integer > > g = new HashMap<> ();
118112 int n = arr. length;
119- for (int i = 0 ; i < n; ++ i ) {
120- idx . computeIfAbsent(arr[i], k - > new ArrayList<> ()). add(i);
113+ for (int i = 0 ; i < n; i ++ ) {
114+ g . computeIfAbsent(arr[i], k - > new ArrayList<> ()). add(i);
121115 }
122- Deque<int[]> q = new LinkedList<> ();
123- Set<Integer > vis = new HashSet<> ();
124- vis. add(0 );
125- q. offer(new int [] {0 , 0 });
126- while (! q. isEmpty()) {
127- int [] e = q. pollFirst();
128- int i = e[0 ], step = e[1 ];
129- if (i == n - 1 ) {
130- return step;
131- }
132- int v = arr[i];
133- ++ step;
134- for (int j : idx. getOrDefault(v, new ArrayList<> ())) {
135- if (! vis. contains(j)) {
136- vis. add(j);
137- q. offer(new int [] {j, step});
116+ boolean [] vis = new boolean [n];
117+ Deque<Integer > q = new ArrayDeque<> ();
118+ q. offer(0 );
119+ vis[0 ] = true ;
120+ for (int ans = 0 ;; ++ ans) {
121+ for (int k = q. size(); k > 0 ; -- k) {
122+ int i = q. poll();
123+ if (i == n - 1 ) {
124+ return ans;
125+ }
126+ for (int j : g. get(arr[i])) {
127+ if (! vis[j]) {
128+ vis[j] = true ;
129+ q. offer(j);
130+ }
131+ }
132+ g. get(arr[i]). clear();
133+ for (int j : new int [] {i - 1 , i + 1 }) {
134+ if (0 <= j && j < n && ! vis[j]) {
135+ vis[j] = true ;
136+ q. offer(j);
137+ }
138138 }
139- }
140- idx. remove(v);
141- if (i + 1 < n && ! vis. contains(i + 1 )) {
142- vis. add(i + 1 );
143- q. offer(new int [] {i + 1 , step});
144- }
145- if (i - 1 >= 0 && ! vis. contains(i - 1 )) {
146- vis. add(i - 1 );
147- q. offer(new int [] {i - 1 , step});
148139 }
149140 }
150- return - 1 ;
151141 }
152142}
153143```
@@ -158,39 +148,36 @@ class Solution {
158148class Solution {
159149public:
160150 int minJumps(vector<int >& arr) {
161- unordered_map<int, vector<int >> idx ;
151+ unordered_map<int, vector<int >> g ;
162152 int n = arr.size();
163- for (int i = 0; i < n; ++i) idx[ arr[ i]] .push_back(i);
164- queue<pair<int, int>> q;
165- q.emplace(0, 0);
166- unordered_set<int > vis;
167- vis.insert(0);
168- while (!q.empty()) {
169- auto e = q.front();
170- q.pop();
171- int i = e.first, step = e.second;
172- if (i == n - 1) return step;
173- int v = arr[ i] ;
174- ++step;
175- if (idx.count(v)) {
176- for (int j : idx[ v] ) {
177- if (!vis.count(j)) {
178- vis.insert(j);
179- q.emplace(j, step);
153+ for (int i = 0; i < n; ++i) {
154+ g[ arr[ i]] .push_back(i);
155+ }
156+ vector<bool > vis(n);
157+ queue<int > q{{0}};
158+ vis[ 0] = true;
159+ for (int ans = 0;; ++ans) {
160+ for (int k = q.size(); k; --k) {
161+ int i = q.front();
162+ q.pop();
163+ if (i == n - 1) {
164+ return ans;
165+ }
166+ for (int j : g[ arr[ i]] ) {
167+ if (!vis[ j] ) {
168+ vis[ j] = true;
169+ q.push(j);
170+ }
171+ }
172+ g[ arr[ i]] .clear();
173+ for (int j : {i - 1, i + 1}) {
174+ if (0 <= j && j < n && !vis[ j] ) {
175+ vis[ j] = true;
176+ q.push(j);
180177 }
181178 }
182- idx.erase(v);
183- }
184- if (i + 1 < n && !vis.count(i + 1)) {
185- vis.insert(i + 1);
186- q.emplace(i + 1, step);
187- }
188- if (i - 1 >= 0 && !vis.count(i - 1)) {
189- vis.insert(i - 1);
190- q.emplace(i - 1, step);
191179 }
192180 }
193- return -1;
194181 }
195182};
196183```
@@ -199,38 +186,76 @@ public:
199186
200187```go
201188func minJumps(arr []int) int {
202- idx := map[int][]int{}
203- for i, v := range arr {
204- idx[v ] = append(idx[v ], i)
189+ g := map[int][]int{}
190+ for i, x := range arr {
191+ g[x ] = append(g[x ], i)
205192 }
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})
193+ n := len(arr)
194+ q := []int{0}
195+ vis := make([]bool, n)
196+ vis[0] = true
197+ for ans := 0; ; ans++ {
198+ for k := len(q); k > 0; k-- {
199+ i := q[0]
200+ q = q[1:]
201+ if i == n-1 {
202+ return ans
203+ }
204+ for _, j := range g[arr[i]] {
205+ if !vis[j] {
206+ vis[j] = true
207+ q = append(q, j)
208+ }
209+ }
210+ g[arr[i]] = nil
211+ for _, j := range []int{i - 1, i + 1} {
212+ if 0 <= j && j < n && !vis[j] {
213+ vis[j] = true
214+ q = append(q, j)
215+ }
221216 }
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})
231217 }
232218 }
233- return -1
219+ }
220+ ```
221+ 222+ #### TypeScript
223+ 224+ ``` ts
225+ function minJumps(arr : number []): number {
226+ const : Map <number , number []> = new Map ();
227+ const = arr .length ;
228+ for (let i = 0 ; i < n ; ++ i ) {
229+ if (! g .has (arr [i ])) {
230+ g .set (arr [i ], []);
231+ }
232+ g .get (arr [i ])! .push (i );
233+ }
234+ let q: number [] = [0 ];
235+ const : boolean [] = Array (n ).fill (false );
236+ vis [0 ] = true ;
237+ for (let ans = 0 ; ; ++ ans ) {
238+ const : number [] = [];
239+ for (const of q ) {
240+ if (i === n - 1 ) {
241+ return ans ;
242+ }
243+ for (const of g .get (arr [i ])! ) {
244+ if (! vis [j ]) {
245+ vis [j ] = true ;
246+ nq .push (j );
247+ }
248+ }
249+ g .get (arr [i ])! .length = 0 ;
250+ for (const of [i - 1 , i + 1 ]) {
251+ if (j >= 0 && j < n && ! vis [j ]) {
252+ vis [j ] = true ;
253+ nq .push (j );
254+ }
255+ }
256+ }
257+ q = nq ;
258+ }
234259}
235260```
236261
0 commit comments