Skip to content

feat: add solutions to lc problems: No.1345,1347 #3463

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Aug 31, 2024
Merged

feat: add solutions to lc problems: No.1345,1347 #3463

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
d07de4b
feat: add solutions to lc problem: No.1347
yanglbme Aug 31, 2024
392a2e0
feat: add solutions to lc problem: No.1345
yanglbme Aug 31, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
237 changes: 131 additions & 106 deletions solution/1300-1399/1345.Jump Game IV/README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -85,69 +85,59 @@ tags:
```python
class Solution:
def minJumps(self, arr: List[int]) -> int:
idx = defaultdict(list)
for i, v in enumerate(arr):
idx[v].append(i)
q = deque([(0, 0)])
g = defaultdict(list)
for i, x in enumerate(arr):
g[x].append(i)
q = deque([0])
vis = {0}
while q:
i, step = q.popleft()
if i == len(arr) - 1:
return step
v = arr[i]
step += 1
for j in idx[v]:
if j not in vis:
vis.add(j)
q.append((j, step))
del idx[v]
if i + 1 < len(arr) and (i + 1) not in vis:
vis.add(i + 1)
q.append((i + 1, step))
if i - 1 >= 0 and (i - 1) not in vis:
vis.add(i - 1)
q.append((i - 1, step))
ans = 0
while 1:
for _ in range(len(q)):
i = q.popleft()
if i == len(arr) - 1:
return ans
for j in (i + 1, i - 1, *g.pop(arr[i], [])):
if 0 <= j < len(arr) and j not in vis:
q.append(j)
vis.add(j)
ans += 1
```

#### Java

```java
class Solution {
public int minJumps(int[] arr) {
Map<Integer, List<Integer>> idx = new HashMap<>();
Map<Integer, List<Integer>> g = new HashMap<>();
int n = arr.length;
for (int i = 0; i < n; ++i) {
idx.computeIfAbsent(arr[i], k -> new ArrayList<>()).add(i);
for (int i = 0; i < n; i++) {
g.computeIfAbsent(arr[i], k -> new ArrayList<>()).add(i);
}
Deque<int[]> q = new LinkedList<>();
Set<Integer> vis = new HashSet<>();
vis.add(0);
q.offer(new int[] {0, 0});
while (!q.isEmpty()) {
int[] e = q.pollFirst();
int i = e[0], step = e[1];
if (i == n - 1) {
return step;
}
int v = arr[i];
++step;
for (int j : idx.getOrDefault(v, new ArrayList<>())) {
if (!vis.contains(j)) {
vis.add(j);
q.offer(new int[] {j, step});
boolean[] vis = new boolean[n];
Deque<Integer> q = new ArrayDeque<>();
q.offer(0);
vis[0] = true;
for (int ans = 0;; ++ans) {
for (int k = q.size(); k > 0; --k) {
int i = q.poll();
if (i == n - 1) {
return ans;
}
for (int j : g.get(arr[i])) {
if (!vis[j]) {
vis[j] = true;
q.offer(j);
}
}
g.get(arr[i]).clear();
for (int j : new int[] {i - 1, i + 1}) {
if (0 <= j && j < n && !vis[j]) {
vis[j] = true;
q.offer(j);
}
}
}
idx.remove(v);
if (i + 1 < n && !vis.contains(i + 1)) {
vis.add(i + 1);
q.offer(new int[] {i + 1, step});
}
if (i - 1 >= 0 && !vis.contains(i - 1)) {
vis.add(i - 1);
q.offer(new int[] {i - 1, step});
}
}
return -1;
}
}
```
Expand All @@ -158,39 +148,36 @@ class Solution {
class Solution {
public:
int minJumps(vector<int>& arr) {
unordered_map<int, vector<int>> idx;
unordered_map<int, vector<int>> g;
int n = arr.size();
for (int i = 0; i < n; ++i) idx[arr[i]].push_back(i);
queue<pair<int, int>> q;
q.emplace(0, 0);
unordered_set<int> vis;
vis.insert(0);
while (!q.empty()) {
auto e = q.front();
q.pop();
int i = e.first, step = e.second;
if (i == n - 1) return step;
int v = arr[i];
++step;
if (idx.count(v)) {
for (int j : idx[v]) {
if (!vis.count(j)) {
vis.insert(j);
q.emplace(j, step);
for (int i = 0; i < n; ++i) {
g[arr[i]].push_back(i);
}
vector<bool> vis(n);
queue<int> q{{0}};
vis[0] = true;
for (int ans = 0;; ++ans) {
for (int k = q.size(); k; --k) {
int i = q.front();
q.pop();
if (i == n - 1) {
return ans;
}
for (int j : g[arr[i]]) {
if (!vis[j]) {
vis[j] = true;
q.push(j);
}
}
g[arr[i]].clear();
for (int j : {i - 1, i + 1}) {
if (0 <= j && j < n && !vis[j]) {
vis[j] = true;
q.push(j);
}
}
idx.erase(v);
}
if (i + 1 < n && !vis.count(i + 1)) {
vis.insert(i + 1);
q.emplace(i + 1, step);
}
if (i - 1 >= 0 && !vis.count(i - 1)) {
vis.insert(i - 1);
q.emplace(i - 1, step);
}
}
return -1;
}
};
```
Expand All @@ -199,38 +186,76 @@ public:

```go
func minJumps(arr []int) int {
idx := map[int][]int{}
for i, v := range arr {
idx[v] = append(idx[v], i)
g := map[int][]int{}
for i, x := range arr {
g[x] = append(g[x], i)
}
vis := map[int]bool{0: true}
type pair struct{ idx, step int }
q := []pair{{0, 0}}
for len(q) > 0 {
e := q[0]
q = q[1:]
i, step := e.idx, e.step
if i == len(arr)-1 {
return step
}
step++
for _, j := range idx[arr[i]] {
if !vis[j] {
vis[j] = true
q = append(q, pair{j, step})
n := len(arr)
q := []int{0}
vis := make([]bool, n)
vis[0] = true
for ans := 0; ; ans++ {
for k := len(q); k > 0; k-- {
i := q[0]
q = q[1:]
if i == n-1 {
return ans
}
for _, j := range g[arr[i]] {
if !vis[j] {
vis[j] = true
q = append(q, j)
}
}
g[arr[i]] = nil
for _, j := range []int{i - 1, i + 1} {
if 0 <= j && j < n && !vis[j] {
vis[j] = true
q = append(q, j)
}
}
}
delete(idx, arr[i])
if i+1 < len(arr) && !vis[i+1] {
vis[i+1] = true
q = append(q, pair{i + 1, step})
}
if i-1 >= 0 && !vis[i-1] {
vis[i-1] = true
q = append(q, pair{i - 1, step})
}
}
return -1
}
```

#### TypeScript

```ts
function minJumps(arr: number[]): number {
const g: Map<number, number[]> = new Map();
const n = arr.length;
for (let i = 0; i < n; ++i) {
if (!g.has(arr[i])) {
g.set(arr[i], []);
}
g.get(arr[i])!.push(i);
}
let q: number[] = [0];
const vis: boolean[] = Array(n).fill(false);
vis[0] = true;
for (let ans = 0; ; ++ans) {
const nq: number[] = [];
for (const i of q) {
if (i === n - 1) {
return ans;
}
for (const j of g.get(arr[i])!) {
if (!vis[j]) {
vis[j] = true;
nq.push(j);
}
}
g.get(arr[i])!.length = 0;
for (const j of [i - 1, i + 1]) {
if (j >= 0 && j < n && !vis[j]) {
vis[j] = true;
nq.push(j);
}
}
}
q = nq;
}
}
```

Expand Down
Loading
Loading