Leetcode错题集-Q403-青蛙过河

原题描述

LeetCode第403题 青蛙过河
难度：困难
一只青蛙想要过河。 假定河流被等分为若干个单元格，并且在每一个单元格内都有可能放有一块石子（也有可能没有）。 青蛙可以跳上石子，但是不可以跳入水中。

给你石子的位置列表 stones（用单元格序号 升序 表示）， 请判定青蛙能否成功过河（即能否在最后一步跳至最后一块石子上）。

开始时， 青蛙默认已站在第一块石子上，并可以假定它第一步只能跳跃一个单位（即只能从单元格 1 跳至单元格 2 ）。

如果青蛙上一步跳跃了k个单位，那么它接下来的跳跃距离只能选择为k-1、k或 k+1个单位。 另请注意，青蛙只能向前方（终点的方向）跳跃。

我的思路

我首先想到了递归，主要原因是，青蛙从A点跳到B点的过程与从B点跳到C点的过程完全一致。
在跳跃过程中，我称上一个石头的坐标为parent，当前石头的坐标为target。
递归的主要过程为：

1. 根据stones[parent]和stones[target]计算上一次跳跃的距离step；
2. i从target+1开始，遍历整个 stones：
   2.1. 如果stones[i]太近了，跳不到，这直接跳过本轮循环；
   2.2. 如果stones[i]太远了，而i之后的节点只会更远，因此直接跳出循环；
   2.3. 经过上面两步，说明石头i可以达到，因此可以递归调用本函数：如果结果为true，则可以直接返回true，如果结果为false，则进入下一轮循环；
3. 跳出循环，说明上面的循环没有找到结果为true的解答，应当返回false。

递归的中止条件：如果target正好是最后一块石头，则说明找到了一中解决方案，此时应该直接返回true。

由于第一次的步长为1，因此递归外围的主要逻辑为：

1. 判断第1步的长度是否为1，如果不是则直接返回false；
2. 如果是，则初始递归为从石头0跳到石头1，并等待返回结果。

我的尝试

第一次

class Solution {
    public boolean canCross(int[] stones) {
        if (stones[1] - stones[0] == 1) {
            return jump(stones, 0, 1);
        }
        return false;
    }
    
    public boolean jump(int[] stones, int parent, int target){
        if (target == stones.length - 1){
            return true;
        }
        
        int step = stones[target] - stones[parent];
        for (int i = target + 1; i < stones.length; i++) {
            if (stones[target] + step -1 > stones[i]){
                continue;
            }else if (stones[target] + step + 1 < stones[i]){
                break;
            }
            if(jump(stones,target,i)){
                return true;
            }
        }
        return false;
    }
}

提交结果：超出时间限制
输入：[0,1,2,3,4,5,…,996,997,998,999999]

分析原因

显然是时间复杂度过高，我们设n=stones.length，对于每一次遍历，我们都需要至多计算n-target次，由于递归的复杂度是乘算的，因此算法的总体时间复杂度是指数级别的，自然会超时。

解决思路

超时也意味着我们的代码中存在这大量的重复计算，在上面的例子中，例如0 → 1 → 2 → 3 → 4 →…与0 → 1 → 3 → 4 →…就存在着重复计算方案3 → 4的可行性。实际上，3 → 4的可行性一旦确定，便不会在更改。因此，我们可以将从parent→target的结果记录下来，下次调用的时候，直接给出结果就行。另一方面，对于结果为true的方案，代码会一路返回到头，于是我们实际上只需要记录哪些节点被扫描过，这些扫描过的节点都是不可行的方案。
由于parent与target都可以从0开始一直取到stones.length-1，因此我们可以制造一个矩阵来存储这些数据。

第二次

class Solution {
    boolean [][] flag;
    public boolean canCross(int[] stones) {
        if (stones[1] - stones[0] == 1) {
            flag = new boolean[stones.length][stones.length];
            System.out.println(flag[0][0]);
            return jump(stones, 0, 1);
        }
        return false;
    }

    public boolean jump(int[] stones, int parent, int target){
        if (target == stones.length - 1){
            return true;
        }
        if (flag[parent][target]){
            return false;
        }

        int step = stones[target] - stones[parent];
        for (int i = target + 1; i < stones.length; i++) {
            if (stones[target] + step -1 > stones[i]){
                continue;
            }else if (stones[target] + step + 1 < stones[i]){
                break;
            }
            if(jump(stones,target,i)){
                return true;
            }
        }
        flag[parent][target] = true;
        return false;
    }
}

提交结果：通过