Frog Jump



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 < 2³¹.
• 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.

题目的大意是给定一条河中所有石头的位置，要求跳到下一个石头的距离必须在上一次跳跃的距离的正负一的区间内，我们要根据题目给定的数组确定能否到达最后一块石头。

我最开始的做法是用分治策略来做，利用一个递归函数，每次确定一个当前点和上一次跳跃的距离，以这两个变量为函数的变量，在函数中只需要确定在当前的条件下，下一个能够到达的点，然后再以该点作为新的当前点来递归地调用函数，直到不能继续往前走或者已经到达最后一个石头。

这个做法虽然可以得到正确的答案，但是提交的时候就显示超时了，原因是因为我进行了太多的重复计算。所以我就改变了方法，使用动态规划的方法来解这道题。

大概的思路是利用一个二维数组记录两个石头之间的可达关系，如果可以到达，就用这个数组记录下它们跳跃的距离。我们从第一个点开始拓展，对于每一个点，判断它前面的所以点是否有点可以到达它，如果可以，就以它们跳跃的距离来搜索接下来可以到达的点，并对二维数组进行更新。

对所以的点都进行了以上操作以后，就只需要检查二维数组，查看是否有点能够到达最后一个点，如果有就说明可以到达最后一个石头，没有则说明不可以。

在程序中最多有3重循环，所以这个程序的复杂度是O（n^3），是可以通过LeetCode的测试的。

从这个问题也可以看出分治策略和动态规划的区别，分治策略会进行很多重复的运算，如果不能迅速地减少问题的规模，那么分治策略的效率是比较低的，而动态规划则可以在问题规模变化不大的情况下，得到一个比较好的效率。以这道题为例，我认为我设计的动态规划的算法并不算好，还是进行了许多重复的计算，但是依然比我利用比较相似方法的分治策略的方法效率高。

我并不是说动态规划会比分治好，只是这道题比较适合用动态规划来做，也或者是我没有想到好的分治策略的算法来解这道题。

以下是程序的源代码：

int a[1100][1100];
class Solution {
public:
    
    bool canCross(vector<int>& stones) {
        if(stones[1]!=1) return false;
    	for(int i=0;i<stones.size();i++)
    		for(int j=0;j<stones.size();j++) a[i][j]=0;
    	a[0][1]=1;
    	for(int i=1;i<stones.size();i++)
    	{
    		for(int j=0;j<i;j++)
    		{
    			if(a[j][i]!=0)
    			{
    				int t=search(stones,stones[i]+a[j][i]-1,i);
    				if(t!=-1) a[i][t]=stones[t]-stones[i];
    				t=search(stones,stones[i]+a[j][i],i);
    				if(t!=-1) a[i][t]=stones[t]-stones[i];
    				t=search(stones,stones[i]+a[j][i]+1,i);
    				if(t!=-1) a[i][t]=stones[t]-stones[i];
    			}
    		}
    	}
    	for(int i=0;i<stones.size();i++)
    		if(a[i][stones.size()-1]!=0) return true;
    	return false;    
    }
    
    int search(vector<int>& stones,int key,int index)
    {
    	for(int i=index+1;i<stones.size();i++)
    	{
    		if(stones[i]==key) return i;
    		if(stones[i]>key) break;
    	}
    	return -1;
    }
};