403. Frog Jump

403 . Frog Jump

Difficulty: Hard

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.

解题思路

先翻译下题目，题目的意思是河道被分为x份，然后有然后有的unit中有石头有的没有，给出一串数字表示之间的距离，第一个石头的距离必定为1（要注意，如果不为一直接返回false），其他就任意了，不过得按照从小到大的顺序储存。然后就是一只小青蛙从河边开始跳，最开始只能跳1，之后呢如果之前一次跳的是k，那么下一次它可以跳k，k+1，k-1三种距离中的一个。我们要找出小青蛙能不能过河。

其实问题是一个dp问题，就是借助之前已经能达到的点来判断当前点能否达到的问题，一旦不能就立刻看下一个点，当所有点搜索完毕后，观察最后一个点有无路径到达即可。因为单纯的二维数组遍历似乎会超时，我使用了unordered_map，unordered_set来实现代码。

具体实现

class Solution {
public:
    bool canCross(vector<int>& stones) {
        unordered_map<int,unordered_set<int> > finding;
        finding[0].insert(0);
        int i,j,max_path;
        if(stones[1]!=1) return false;
        finding[1].insert(1);
        for(i = 1;i < stones.size();i++)
        {
            for(int j = i + 1;j < stones.size();j++)
            {
                int dis_temp = stones[j] - stones[i];
                if(finding[i].count(dis_temp-1)||finding[i].count(dis_temp)||finding[i].count(dis_temp+1)){
                    finding[j].insert(dis_temp);
                    max_path = max(dis_temp,max_path);
                }
                if(dis_temp > max_path) break;


            }

        }
        if(finding[stones.size() - 1].size() > 0) return true;
        else return false;
    }
};

ps:真心一般。。。