LeetCode 403青蛙过河：动态规划与BFS解法详解

1. 问题解析：LeetCode 403.青蛙过河

这道题目描述了一只青蛙想要过河的场景。河中有若干石头，青蛙需要从起点（第一个石头）跳到终点（最后一个石头）。青蛙的跳跃规则比较特殊：

• 第一次跳跃时，只能跳1个单位距离
• 后续每次跳跃时，跳跃距离只能在上次跳跃距离的±1范围内变化

举个例子，如果青蛙上次跳了3个单位，那么这次可以跳2、3或4个单位。我们需要判断青蛙是否能够成功到达终点。

1.1 问题建模

这个问题可以抽象为一个状态转移问题。我们需要跟踪两个关键信息：

1. 当前所在的石头位置
2. 上次跳跃的距离（决定了这次可以跳多远）

这种"当前状态由前序状态决定"的特点，正是动态规划适用的典型场景。我们可以用dp[i][k]来表示：是否能够以k的跳跃距离到达第i个石头。

1.2 边界条件分析

有几个关键边界条件需要注意：

1. 第一次跳跃必须是1个单位，所以如果stones[1] != 1，可以直接返回false
2. 跳跃距离必须为正数（不能原地跳或往回跳）
3. 必须确保目标位置确实有石头（不能跳到水里）

2. 动态规划解法详解

2.1 基本DP思路

我们使用一个哈希表来记录每个石头位置可以到达的跳跃距离集合。具体步骤如下：

1. 初始化：创建一个映射，为每个石头位置初始化一个空集合
2. 起点设置：在位置0（起点）添加跳跃距离0（因为第一次跳跃必须是1）
3. 状态转移：对于每个石头位置，遍历所有可能的上一跳距离k，尝试k-1、k、k+1三种跳跃
4. 终止条件：检查终点位置的集合是否非空

2.2 Java实现解析

java复制class Solution {
    public boolean canCross(int[] stones) {
        int n = stones.length;
        if (stones[1] != 1) return false; // 第一步必须跳1个单位
        
        // dp[i] 表示到达第i个石头时，上一跳的距离集合
        Map<Integer, Set<Integer>> dp = new HashMap<>();
        for (int stone : stones) {
            dp.put(stone, new HashSet<>());
        }
        dp.get(0).add(0);  // 从起点开始，上一跳距离为0
        
        for (int i = 0; i < n; i++) {
            int curPos = stones[i];
            Set<Integer> jumps = dp.get(curPos);
            
            for (int k : jumps) {
                // 尝试跳k-1, k, k+1的距离
                for (int step = k - 1; step <= k + 1; step++) {
                    if (step <= 0) continue;  // 步长必须为正
                    
                    int nextPos = curPos + step;
                    if (dp.containsKey(nextPos)) {
                        dp.get(nextPos).add(step);
                    }
                }
            }
        }
        
        return !dp.get(stones[n - 1]).isEmpty();
    }
}

2.3 复杂度分析

• 时间复杂度：O(n²)，最坏情况下每个石头位置需要处理O(n)种跳跃距离
• 空间复杂度：O(n²)，需要存储每个石头位置的可能跳跃距离

3. BFS解法详解

3.1 BFS思路

广度优先搜索是另一种解决此问题的有效方法。我们可以将每个状态表示为（当前位置，上一跳距离），然后系统地探索所有可能的跳跃序列。

3.2 BFS实现

java复制class Solution {
    public boolean canCross(int[] stones) {
        int n = stones.length;
        if (stones[1] != 1) return false;

        // 用哈希表存储石头位置，便于快速查找
        Map<Integer, Integer> stoneMap = new HashMap<>();
        for (int i = 0; i < n; i++) {
            stoneMap.put(stones[i], i);
        }
        
        // visited[i][k]表示是否以跳跃距离k到达过第i个石头
        boolean[][] visited = new boolean[n][n + 1];
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{1, 1});  // {位置索引, 上一跳距离}
        visited[1][1] = true;
        
        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            int idx = cur[0];
            int k = cur[1];
            
            if (idx == n - 1) return true;
            
            // 尝试跳k-1, k, k+1
            for (int step = k - 1; step <= k + 1; step++) {
                if (step <= 0) continue;
                
                int nextPos = stones[idx] + step;
                if (stoneMap.containsKey(nextPos)) {
                    int nextIdx = stoneMap.get(nextPos);
                    if (!visited[nextIdx][step]) {
                        visited[nextIdx][step] = true;
                        queue.offer(new int[]{nextIdx, step});
                    }
                }
            }
        }
        
        return false;
    }
}

3.3 BFS优化点

1. 使用哈希表快速查找石头位置，避免线性搜索
2. 使用visited数组避免重复处理相同状态
3. 提前终止：一旦到达终点立即返回true

4. DFS+记忆化解法

4.1 递归思路

深度优先搜索配合记忆化也是一种直观的解决方案。我们从起点开始，尝试所有可能的跳跃序列，使用记忆化技术避免重复计算。

4.2 实现代码

java复制class Solution {
    public boolean canCross(int[] stones) {
        int n = stones.length;
        Map<Integer, Integer> stoneMap = new HashMap<>();  
        for (int i = 0; i < n; i++) {  
            stoneMap.put(stones[i], i);  
        }
    
        // memo[i][k]表示从第i个石头，以跳跃距离k出发，是否能到达终点
        Boolean[][] memo = new Boolean[n][n + 1];
        return dfs(0, 0, stones, stoneMap, memo);
    }
    
    private boolean dfs(int idx, int k, int[] stones, 
                       Map<Integer, Integer> stoneMap, Boolean[][] memo) {
        if (idx == stones.length - 1) return true;
        if (memo[idx][k] != null) return memo[idx][k];
        
        boolean res = false;
        // 尝试跳k-1, k, k+1
        for (int step = Math.max(1, k - 1); step <= k + 1; step++) {
            int nextPos = stones[idx] + step;
            if (stoneMap.containsKey(nextPos)) {
                int nextIdx = stoneMap.get(nextPos);
                if (dfs(nextIdx, step, stones, stoneMap, memo)) {
                    res = true;
                    break;
                }
            }
        }
        
        memo[idx][k] = res;
        return res;
    }
}

4.3 记忆化技巧

1. 使用Boolean数组而不是boolean数组，可以区分"未计算"和"计算结果"
2. 在递归返回前存储计算结果
3. 递归开始时先检查是否已经计算过

5. 性能对比与选择建议

5.1 三种方法对比

5.2 选择建议

1. 面试中推荐使用动态规划解法，因为它最能体现对问题的理解和分析能力
2. 如果题目要求找出具体跳跃路径，BFS可能更适合
3. DFS+记忆化适合在思考问题时作为初步解决方案

6. 常见错误与调试技巧

6.1 常见错误

1. 忘记处理第一次跳跃必须为1的条件
2. 没有正确处理跳跃距离必须为正数的边界条件
3. 在BFS/DFS中没有正确处理重复状态，导致无限循环
4. 记忆化数组大小设置不当（注意k的范围可能达到n）

6.2 调试技巧

1. 打印关键状态：在状态转移时打印当前石头位置和跳跃距离
2. 小规模测试：先用小的测试用例验证基本逻辑
3. 边界测试：专门测试stones=[0,1]和stones=[0,2]等情况
4. 可视化：画出石头位置和可能的跳跃路径

7. 问题变种与扩展

7.1 变种问题

1. 如果青蛙第一次可以跳任意正数距离，如何修改解法？
2. 如果要求找出所有可能的跳跃路径，如何解决？
3. 如果石头位置不是排序好的，需要先排序吗？

7.2 扩展思考

1. 如何优化空间复杂度？是否可以只保留必要的状态？
2. 如果石头数量非常大（n=10^5），是否有更高效的解法？
3. 如何将此问题建模为图论问题，并使用图算法解决？

8. 实际应用场景

虽然这个问题看起来像是一个纯粹的算法练习，但它实际上模拟了许多现实世界中的场景：

1. 机器人路径规划：考虑移动限制和障碍物
2. 金融投资策略：每次调整投资额度有最大限制
3. 游戏AI设计：角色移动的规则限制

理解这类问题的解决方法，有助于我们在面对类似约束条件下的决策问题时，能够快速建立有效的解决方案。