LeetCode 818. Race Car

原题链接在这里：https://leetcode.com/problems/race-car/

题目：

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.

题解：

Use BFS to find out shortest sequence. 

Each step, there are 2 possibilities, either A or R. Maintain a set to store visited state.

If current position is alrady beyond 2 * target, it can't make shortest path.

Time Complexity: O(nlogn). n = target. totoally there are 2*n positions, each position could be visited 2*logn times at most. Since the speed could not be beyond logn.

Space: O(n).

AC Java:

class Solution {
    public int racecar(int target) {
        if(target == 0){
            return 0;
        }
        
        int step = 0;
        LinkedList<int []> que = new LinkedList<>();
        que.add(new int[]{0, 1});
        int curCount = 1;
        int nextCount = 0;
        
        HashSet<String> visited = new HashSet<>();
        visited.add(0 + "," + 1);
        
        while(!que.isEmpty()){
            int [] cur = que.poll();
            curCount--;
            
            if(cur[0] == target){
                return step;
            }
            
            int [] next1 = new int[]{cur[0]+cur[1], 2*cur[1]};
            int [] next2 = new int[]{cur[0], cur[1] > 0 ? -1 : 1};
            if(0<next1[0] && next1[0]<=target*2 && !visited.contains(next1[0] + "," + next1[1])){
                que.add(next1);
                visited.add(next1[0] + "," + next1[1]);
                nextCount++;
            }
            
            if(!visited.contains(next2[0] + "," + next2[1])){
                que.add(next2);
                visited.add(next2[0] + "," + next2[1]);
                nextCount++;
            }
            
            if(curCount == 0){
                curCount = nextCount;
                nextCount = 0;
                step++;
            }
        }
        
        return -1;
    }
}