[leetcode] 403. 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 < 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.

今天的题目是判断青蛙能否按给定规则顺利过河，题目难度为Hard。

最直观的想法是从初始位置开始尝试所有可能的跳跃值k，如果跳跃距离k之后能够落到某个石头上，则根据该k值将k-1、k和k+1加入该石头的跳跃值集合，这样依次遍历所有石头直至跳到最后一个石头上。每个位置可能有多种跳跃值k，这里我们将每个位置的k值存在Hash Table中，再将每个位置作为键值将k集合存入Hash Table来方便查找比较。这样通过类似广度优先的思路即可得出最终结果，具体代码：

class Solution {
public:
    bool canCross(vector<int>& stones) {
        unordered_map<int, unordered_set<int>> hash;
        for(auto s:stones) hash[s] = unordered_set<int>();
        hash[0].insert(1);
        for(auto s:stones) {
            for(auto k:hash[s]) {
                int next = s + k;
                if(next == stones.back()) return true;
                if(hash.find(next) != hash.end()) {
                    if(k-1 > 0) hash[next].insert(k-1);
                    hash[next].insert(k);
                    hash[next].insert(k+1);
                }
            }
        }
        return false;
    }
};

看了别人的代码，还有通过深度优先的思路来解决问题的，分享给大家，具体代码：

class Solution {
    unordered_map<int, bool> dp;

    bool ChkCross(vector<int>& stones, int pos = 0, int k = 0) {
        int key = pos | k << 11;
    
        if (dp.count(key) > 0)
            return dp[key];
    
        for (int i = pos + 1; i < stones.size(); i++) {
            int gap = stones[i] - stones[pos];
            if (gap < k - 1)
                continue;
            if (gap > k + 1)
                return dp[key] = false;
            if (ChkCross(stones, i, gap))
                return dp[key] = true;
        }
    
        return dp[key] = (pos == stones.size() - 1);
    }
public:
    bool canCross(vector<int>& stones) {
        return ChkCross(stones);
    }
};

其中key的处理比较巧妙，将每个位置和一种跳跃值k作为整体来当做键值使用，大家可以学习一下。采用深度优先的方法递归处理问题时，可能会有重复的子问题，因此这里又用动态规划的思想避免了相同子问题的重复处理。具体思路就不再讲了，相信大家看了代码都能够理解。