403. Frog Jump leetcode

A frog is crossing a river. The river is divided into x units and at each unit there may or may not exist a stone. The frog can jump on a stone, but it must not jump into the water.

Given a list of stones' positions (in units) in sorted ascending order, determine if the frog is able to cross the river by landing on the last stone. Initially, the frog is on the first stone and assume the first jump must be 1 unit.

If the frog's last jump was k units, then its next jump must be either k - 1, k, or k + 1 units. Note that the frog can only jump in the forward direction.

Note:

• The number of stones is ≥ 2 and is < 1,100.
• Each stone's position will be a non-negative integer < 231.
• The first stone's position is always 0.

Example 1:

[0,1,3,5,6,8,12,17]

There are a total of 8 stones.
The first stone at the 0th unit, second stone at the 1st unit,
third stone at the 3rd unit, and so on...
The last stone at the 17th unit.

Return true. The frog can jump to the last stone by jumping 
1 unit to the 2nd stone, then 2 units to the 3rd stone, then 
2 units to the 4th stone, then 3 units to the 6th stone, 
4 units to the 7th stone, and 5 units to the 8th stone.

Example 2:

[0,1,2,3,4,8,9,11]

Return false. There is no way to jump to the last stone as 
the gap between the 5th and 6th stone is too large.

题目大意：给定石头间的距离，第一块石头即起点为0，第一次跳跃的步数一定是1，之后每跳跃一次的距离为k-1，k或者k，k是上一次跳跃的大小，判断是否能够跳到终点，注意不能往后跳。

一开始我的想法很简单，直接递归调用，没有悬念的TLE。。。代码如下

class Solution {
    Map<Integer, Integer> map = new TreeMap<>();
	int max;
	public boolean canCross(int[] stones) {
		max=stones[stones.length-1];
		for(int i=0;i<stones.length;i++) {
			map.put(stones[i], 1);
		}
		return dfs(1,1);
	}
	boolean dfs(int now,int count) {
		if(now==max)
			return true;
		if(!map.containsKey(now))
			return false;
		if(count==1) {
			if(dfs(now+count,count))
				return true;
			if(dfs(now+count+1,count+1))
				return true;
		}
		else {
			if (dfs(now + count - 1, count - 1))
				return true;
			if (dfs(now + count, count))
				return true;
			if (dfs(now + count + 1, count + 1))
				return true;
		}
		return false;
	}
}

之后想了下，开了个数组来保存跳跃失败的信息，cannot[i][j]代表在第i块石头以步数j能否到达终点，每次递归调用时进行判断，然后就AC了

class Solution {
    Map<Integer, Integer> map = new TreeMap<>();
	int max;
	int[][] cannot;
	public boolean canCross(int[] stones) {
		max=stones[stones.length-1];
		cannot=new int[1000][1200];
		for(int i=0;i<stones.length;i++) {
			map.put(stones[i], i);
		}
		return dfs(1,1);
	}
	boolean dfs(int now,int count) {
		if(now==max)
			return true;
		if(!map.containsKey(now)||cannot[map.get(now)][count]==1)
			return false;
		if(count==1) {
			if(dfs(now+count,count))
				return true;
			if(dfs(now+count+1,count+1))
				return true;
		}
		else {
			if (dfs(now + count - 1, count - 1))
				return true;
			if (dfs(now + count, count))
				return true;
			if (dfs(now + count + 1, count + 1))
				return true;
		}
		cannot[map.get(now)][count]=1;
		return false;
	}
}

看了下discuss大佬们的代码，发现一个很有意思的评论。

大意如下：如果用1,5,100块钱来凑齐601块钱，最好就是先从大的钱开始凑起。就是说递归的顺序很重要，先把步数比较大的情况遍历完。

前面我是从步数小的开始遍历，改变了下遍历顺序后，果然速度有所提升。

class Solution {
    Map<Integer, Integer> map = new TreeMap<>();
	int max;
	int[][] cannot;
	public boolean canCross(int[] stones) {
		max=stones[stones.length-1];
		cannot=new int[1000][1200];
		for(int i=0;i<stones.length;i++) {
			map.put(stones[i], i);
		}
		return dfs(1,1);
	}
	boolean dfs(int now,int count) {
		if(now==max)
			return true;
		if(!map.containsKey(now)||cannot[map.get(now)][count]==1)
			return false;
		if(count==1) {
			if(dfs(now+count+1,count+1))               //这里的遍历顺序变了下，先遍历步数较大的情况
				return true;
			if(dfs(now+count,count))
				return true;
		}
		else {
			if (dfs(now + count + 1, count + 1))
				return true;
			if (dfs(now + count, count))
				return true;
			if (dfs(now + count - 1, count - 1))
				return true;
		}
		cannot[map.get(now)][count]=1;
		return false;
	}
}

其实我觉得题目AC了之后，多看看大佬们的代码是更加重要的，还是得多多学习下大佬们的代码，emmmmm