LeetCode 每日一题笔记 日期:2026.05.18 题目:1345. 跳跃游戏 IV

LeetCode 每日一题笔记

0. 前言

  • 日期:2026.05.18
  • 题目:1345. 跳跃游戏 IV
  • 难度:困难
  • 标签:数组、广度优先搜索、哈希表

1. 题目理解

问题描述 :

给定一个整数数组 arr,你从下标 0 开始。每一步可以从下标 i 跳到:

  1. i + 1(需满足 i + 1 < arr.length)
  2. i - 1(需满足 i - 1 >= 0)
  3. 任意 j(需满足 arr[j] == arr[i] 且 j != i)

求到达数组最后一个下标的最少操作次数。

示例:

输入:arr = [100,-23,-23,404,100,23,23,23,3,404]

输出:3

解释:最优路径:0 → 4 → 3 → 9,共3次跳跃。
输入:arr = [7]

输出:0

解释:初始位置就是终点,无需跳跃。

2. 解题思路

核心观察

  • 这是典型的无权图最短路径问题,BFS是天然的最优解法;
  • 同值跳跃会产生大量边,若不优化会导致超时;
  • 关键优化:处理完一个值的所有下标后,立即从哈希表移除该值,避免重复处理。

算法步骤

  1. 预处理哈希表:建立「值 → 对应下标列表」的映射;
  2. BFS初始化:队列加入起点 0,标记已访问;
  3. 逐层遍历队列,每层对应一步操作;
  4. 对当前节点,依次处理:
    • 右邻居 i+1
    • 左邻居 i-1
    • 所有同值下标
  5. 处理完同值下标后,从哈希表移除该值;
  6. 到达终点时立即返回当前步数。

3. 代码实现

java 复制代码
package lc1345;

import java.util.*;

class Solution {

    int bfs(HashMap<Integer, List<Integer>> map, int[] arr) {
        int res = 0;
        int last = arr.length - 1;
        boolean[] visited = new boolean[arr.length];
        Queue<Integer> queue = new LinkedList();
        queue.offer(0);
        while (!queue.isEmpty()) {
            int m = queue.size();
            for (int i = 0; i < m; i++) {
                int n = queue.poll();
                visited[n] = true;
                if (n == last) {
                    return res;
                }
                if (n < last && !visited[n + 1]) {
                    visited[n + 1] = true;
                    queue.offer(n + 1);
                }
                if (n > 0 && !visited[n - 1]) {
                    visited[n - 1] = true;
                    queue.offer(n - 1);
                }
                if (map.containsKey(arr[n])) {
                    List<Integer> list = map.get(arr[n]);
                    for (int num : list) {
                        if (num != n && !visited[num]) {
                            visited[num] = true;
                            queue.offer(num);
                        }
                    }
                    map.remove(arr[n]);
                }
            }
            res += 1;
        }
        return -1;
    }

    public int minJumps(int[] arr) {
        HashMap<Integer, List<Integer>> map = new HashMap<>();
        for (int i = arr.length - 1; i >= 0; i--) {
            map.computeIfAbsent(arr[i], k -> new ArrayList<>()).add(i);
        }
        return bfs(map, arr);
    }
}

4. 代码优化说明

减少if分支判断,合并重复逻辑,使用更高效的队列实现:

java 复制代码
package lc1345;

import java.util.*;

class Solution {
    public int minJumps(int[] arr) {
        int n = arr.length;
        if (n == 1) return 0;
        
        HashMap<Integer, List<Integer>> map = new HashMap<>();
        for (int i = 0; i < n; i++) {
            map.computeIfAbsent(arr[i], k -> new ArrayList<>()).add(i);
        }
        
        boolean[] visited = new boolean[n];
        Queue<Integer> queue = new ArrayDeque<>();
        queue.offer(0);
        visited[0] = true;
        int step = 0;
        
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                int curr = queue.poll();
                if (curr == n - 1) return step;
                
                // 处理左右邻居
                if (curr + 1 < n && !visited[curr + 1]) {
                    visited[curr + 1] = true;
                    queue.offer(curr + 1);
                }
                if (curr - 1 >= 0 && !visited[curr - 1]) {
                    visited[curr - 1] = true;
                    queue.offer(curr - 1);
                }
                
                // 处理同值下标
                if (map.containsKey(arr[curr])) {
                    for (int next : map.get(arr[curr])) {
                        if (!visited[next]) {
                            visited[next] = true;
                            queue.offer(next);
                        }
                    }
                    map.remove(arr[curr]);
                }
            }
            step++;
        }
        return -1;
    }
}

5. 复杂度分析

  • 时间复杂度 :O(n)O(n)O(n)

    • 每个下标最多入队一次,每个值最多处理一次;
    • 哈希表移除操作避免了重复处理同值下标,是不超时的关键。
  • 空间复杂度 :O(n)O(n)O(n)

    • 哈希表、队列、访问数组的空间开销均为线性级。

6. 总结

  • 核心思路:BFS 求最短路径 + 哈希表批量处理同值跳跃;
  • 关键优化:处理完一个值的所有下标后立即从哈希表移除,避免重复入队;
  • 本题是 BFS 在数组跳跃问题中的经典应用,重点考察对时间复杂度的优化能力。
相关推荐
LK_0714 小时前
【力扣】142. 环形链表 II |Python
python·leetcode·链表
Pniubi14 小时前
力扣21合并两个有序链表
算法·leetcode·职场和发展
一条破秋裤15 小时前
【1115】【多线程】【笔记】
前端·chrome·笔记
神明不懂浪漫15 小时前
【第八章】多线程(一)
java·开发语言·经验分享·笔记
文丑颜不良啊15 小时前
LeetCode3341~3360题目解析
java·leetcode
星恒随风17 小时前
MySQL 从零入门(九):事务管理详解——ACID、COMMIT、ROLLBACK、SAVEPOINT 与四种隔离级别
linux·服务器·数据库·笔记·mysql
蒸蒸yyyyzwd17 小时前
秋招操作系统错题本
笔记·八股
星恒随风17 小时前
MySQL 从零入门(十一):视图与用户权限管理详解
linux·服务器·数据库·笔记·mysql
Rain的Java大神之路18 小时前
把数组本身变成哈希表:原地哈希搞定 LeetCode 41「缺失的第一个正数」
java·后端·leetcode
山楂树の18 小时前
Java 泛型:泛型类、泛型方法、泛型接口与通配符
java·开发语言·笔记