Frog Jump--深度遍历，动态规划--leetcode

题意：
给定一串数组，从第一个数字节点开始，向后跳跃，跳跃规则是，只能从0开始跳，最先只能跳到1，设上次跳跃步数为k，接下来可跳的步数是k，k-1，k+1，求是否能够到达最后一个数字（规定只能向后跳跃）。
eg.
[0, 1, 3, 5, 6, 8, 12, 17]
0跳k+1=1步到1，上次跳跃步数k=0
1跳k+1=2步到3，上次跳跃步数k=1
3跳k=2步到5，上次跳跃步数k=2
5跳k+1=3步到8，上次跳跃步数k=2
8跳k+1=4步到12，上次跳跃步数k=3
1跳k+1=5步到17，上次跳跃步数k=4

解法一：
用到深度遍历搜索的算法，一直递归向下搜索能够到达的点。从 第一点开始，判断向后走k-1,k,k+1步是否到达终点。没有到达的话再判断向后走k-1步是否能够到达下一节点，如果是则再继续判断判断向后走k-1,k,k+1步是否到达终点，再按步骤继续下去；没有的话再判断向后走k步是否能够到达下一节点，再按步骤继续下去。

public class FrogJumpSolution {

    public static void main(String[] args) {
        int[] stones = { 0, 1, 3, 5, 6, 8, 12, 17 };
        System.out.println(canCross(stones));
    }

    public static boolean canCross(int[] stones) {
        int i = 0, len = stones.length;
        HashSet<Integer> set = new HashSet<Integer>();
        if (len == 1) {
            if (stones[0] != 0) {
                return false;
            }
        } else if (len == 2) {
            if (stones[0] != 0 || stones[1] != 1) {
                return false;
            }
        } else {
            for (i = 0; i < len - 1; i++) {
                if (i > 2 && stones[i] * 2 <= stones[i + 1]) {
                    return false;
                }
                set.add(stones[i]);
            }
            return canReach(set, 1, 1, stones[len - 1]);
        }
        return true;
    }

    public static boolean canReach(HashSet<Integer> set, int curPos, int lastJump, int lastPos) {
        if (lastPos == curPos + lastJump + 1 || lastPos == curPos + lastJump || lastPos == curPos + lastJump - 1) {
            return true;
        }
        //先跳跃较大的步数，减少递归次数
        if (set.contains(curPos + lastJump + 1)) {
            if (canReach(set, curPos + lastJump + 1, lastJump + 1, lastPos)) {
                return true;
            }
        }
        if (set.contains(curPos + lastJump)) {
            if (canReach(set, curPos + lastJump, lastJump, lastPos)) {
                return true;
            }
        }
        //由于只能向前走，此处满足k-1向前走的条件是k>1
        if (lastJump > 1 && set.contains(curPos + lastJump - 1)) {
            if (canReach(set, curPos + lastJump - 1, lastJump - 1, lastPos)) {
                return true;
            }
        }
        return false;
    }
}

解法二：
用到动态规划的解法，用空间效率换取时间效率。用一个Hashmap存放每个节点能够跳跃的步数集合，从第一个节点开始，遍历前一个节点能够走的步数集合，计算跳跃指定可跳步数后的下个节点，判断该节点是否为最后一个节点，如果不是再计算该节点能够跳跃的步数，再进行遍历。最后，如果整个循环没有任何return遍历结束，则证明该数组不能跳跃到最后节点。

public class Solution {
    public boolean canCross(int[] stones) {
        if (stones.length == 0) {
            return true;
        }

        HashMap<Integer, HashSet<Integer>> map = new HashMap<Integer, HashSet<Integer>>(stones.length);
        map.put(0, new HashSet<Integer>());
        map.get(0).add(1);
        for (int i = 1; i < stones.length; i++) {
            map.put(stones[i], new HashSet<Integer>() );
        }

        for (int i = 0; i < stones.length - 1; i++) {
            int stone = stones[i];
            for (int step : map.get(stone)) {
                int reach = step + stone;
                if (reach == stones[stones.length - 1]) {
                    return true;
                }
                HashSet<Integer> set = map.get(reach);
                if (set != null) {
                    set.add(step);
                    if (step - 1 > 0) set.add(step - 1);
                    set.add(step + 1);
                }
            }
        }

        return false;
    }
}