题目描述

Your car starts at position 0 and speed +1 on an infinite number line. (Your car can go into negative positions.)

Your car drives automatically according to a sequence of instructions A (accelerate) and R (reverse).

When you get an instruction “A”, your car does the following: position += speed, speed *= 2.

When you get an instruction “R”, your car does the following: if your speed is positive then speed = -1 , otherwise speed = 1. (Your position stays the same.)

For example, after commands “AAR”, your car goes to positions 0->1->3->3, and your speed goes to 1->2->4->-1.

Now for some target position, say the length of the shortest sequence of instructions to get there.

Example 1:

Input: 
target = 3
Output: 2
Explanation: 
The shortest instruction sequence is "AA".
Your position goes from 0->1->3.

Example 2:

Input: 
target = 6
Output: 5
Explanation: 
The shortest instruction sequence is "AAARA".
Your position goes from 0->1->3->7->7->6.

Note:

1 <= target <= 10000.

思路

思路一：
BFS，从当前点开始搜，队列存储到达位置及对应的步数，每次从当前步数能到达的位置扩充。有两种扩充方式，加速和转弯。
注意剪枝，如果当前位置>2target 或者 <0 或者 speed > 2target，就没必要搜索了。
每个位置的转弯也只需要做一次，vis标记。
思路二：
记忆化搜索。搜索到达target的最小步数，如果不是一直前进能到达的位置，有两种可能，先到达后一个整数位置，再往回走。或者先到达前一个，往回走，再往前走。

代码

代码一：BFS

class Solution {
    
public:
    int racecar(int target) {
    
        unordered_set<string> vis;
        vis.insert("0_1");
        vis.insert("0_-1"); // pos zhuanxiang
        
        queue<pair<int, int>> que; // pos speed
        que.push({
    0, 1});
        int step = 0;
        
        while(!que.empty()) {
    
            int size = que.size();
            while(size--) {
    
                int pos = que.front().first;
                int speed = que.front().second;
                que.pop();
                
                int pos1 = pos+speed;
                int speed1 = speed*2;
                if (pos1 == target) return step+1;
                if (pos1 < 2*target && abs(speed1) < 2*target && pos1 > 0)
                    que.push({
    pos1, speed1});
                
                int pos2 = pos;
                int speed2 = speed > 0 ? -1 : 1;
                string cur = to_string(pos2)+"_"+to_string(speed2);
                if (vis.count(cur)) continue;
                que.push({
    pos2, speed2});
                vis.insert(cur);
            }
            step++;
        }
        
        return -1;
    }
};

代码二：记忆化搜索

class Solution {
    
public:
    int racecar(int target) {
    
        dp = vector<int>(target+1);
        return dfs(target);
    }
    
    int dfs(int target) {
    
        if (dp[target] > 0) return dp[target];
        int n = ceil(log2(target+1)); // up
        if (1<<n == target+1) return dp[target] = n;
        
        // 2^n - 1 > target
        // AnR
        dp[target] = n + 1 + dfs((1<<n)-1-target);
        
        // A(n-1)RAiR
        for (int m=0; m<n-1; ++m) {
    
            // dp[target] = min(dp[target], n-1+1+m+1+dfs(target- ((1<<(n-1))-1) + (1<<m)-1);
            dp[target] = min(dp[target], n+m+1+dfs(target- (1<<(n-1)) + (1<<m)));
        }
        
        return dp[target];
    }
private:
    vector<int> dp;
};