1654. Minimum Jumps to Reach Home

问题：

一个虫子在x坐标的0位置出发，

求最少跳多少次能跳到x位置。

跳动规则：

• 不能跳到forbidden所示的位置
• 每次可向前跳 a 个距离。
• 每次可向后跳 b 个距离。不能连续向后跳两次。
• 不能跳到<0的坐标位置。

 

Example 1:
Input: forbidden = [14,4,18,1,15], a = 3, b = 15, x = 9
Output: 3
Explanation: 3 jumps forward (0 -> 3 -> 6 -> 9) will get the bug home.

Example 2:
Input: forbidden = [8,3,16,6,12,20], a = 15, b = 13, x = 11
Output: -1

Example 3:
Input: forbidden = [1,6,2,14,5,17,4], a = 16, b = 9, x = 7
Output: 2
Explanation: One jump forward (0 -> 16) then one jump backward (16 -> 7) will get the bug home.

Constraints:
1 <= forbidden.length <= 1000
1 <= a, b, forbidden[i] <= 2000
0 <= x <= 2000
All the elements in forbidden are distinct.
Position x is not forbidden.

　　

解法：BFS

• 状态：
  • 当前位置pos，最后一次跳动类型：向前？向后？
  • visited，记录跳动到过的位置。
• 选择：（next位置>=0）
  • 向前
  • 向后：上一次不能是向后

 

⚠️ 注意：

• 本题没有限制跳动位置的上限，
  • 因此为了防止TLE错误，我们需要判断跳动上限。maxbound
  • 只有a<b的时候，才可以向回跳，也会出现先跳到超过x的位置，再往回跳的情况。
  • 这时候上限为，可能到达的位置 max(x，forbidden)，再往后尝试 最大 a+b
  • 即： max(x，forbidden)+a+b。
• 当a>b的时候，只可能往前跳，此时pos如果超出x，且当前跳法是向后跳，那么之后的跳动只能使得离x越来越远。这种情况就不能再继续尝试了。

 

代码参考：

class Solution {
public:
    int minimumJumps(vector<int>& forbidden, int a, int b, int x) {
        //state: last try type:1:forward, 0:backward
        //       pos
        //if try_type == forward(1): next can try both forward(1) and backward(0)
        //if try_type == backward(0): next can try only forward(1)
        //if a-b>0 && cur_try=backward && next-x>0: continue;
        //if pos in forbidden continue;
        //if pos in visited continue;
        //if pos<0 || pos>2000 continue;
        int tryt[2] = {-b, a};
        unordered_set<int> visited(forbidden.begin(), forbidden.end());
        queue<pair<int, int>> q;
        q.push({0,0});//first try must be forward
        visited.insert(0);
        //get maxbound: only backward case(b>a)
        //max pos we can reach=max(x,forbidden), + try_forwardmax(a+b)
        int maxbound = x;
        for(int fbd:forbidden) maxbound = max(maxbound, fbd);
        maxbound = maxbound+a+b;
        int step = 0;
        while(!q.empty()) {
            int sz = q.size();
            for(int i=0; i<sz; i++) {
                auto [pos, trytype] = q.front();
                q.pop();
                if(pos==x) return step;
                for(int j=0; j<2; j++) {
                    if(trytype==0 && j==0) continue;
                    int next = pos+tryt[j];
                    if(a-b>0 && j==0 && next-x>0) continue;
                    if(next<0 || next>maxbound) continue;
                    if(visited.insert(next).second) {
                        q.push({next, j});
                    }
                }
            }
            step++;
        }
        return -1;
    }
};