Race Car

Race Car - Problem

Dynamic Programming Hard

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 instruction 'A', your car does the following:
position += speed
speed *= 2
When you get 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.

Given a target position target, return the length of the shortest sequence of instructions to get there.

Input & Output

Example 1 — Target at 3

$ Input: target = 3

› Output: 2

💡 Note: Start at position 0, speed 1. First 'A': position becomes 0+1=1, speed becomes 1×2=2. Second 'A': position becomes 1+2=3, speed becomes 2×2=4. We reach target 3 in 2 steps: "AA"

Example 2 — Target at 6

$ Input: target = 6

› Output: 5

💡 Note: Optimal sequence is "AAARA": A(1,2) → A(3,4) → A(7,8) → R(7,-1) → A(6,2). This takes 5 steps to reach target 6

Example 3 — Target at 1

$ Input: target = 1

› Output: 1

💡 Note: Just one 'A' instruction: position becomes 0+1=1, which is the target. Only 1 step needed

Constraints

1 ≤ target ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 30 a Amazon 25

The key insight is to model this as a shortest path problem where each state is (position, speed). The optimal approach uses BFS to explore states level by level, guaranteeing the shortest sequence. Time: O(T × log T), Space: O(T × log T)

Common Approaches

✓ BFS - Shortest Path

⏱️ Time: O(T × log T) Space: O(T × log T)

Model this as a shortest path problem where each state is (position, speed). Use BFS to explore all states level by level, guaranteeing we find the minimum number of steps when we first reach the target.

Brute Force - Try All Sequences

⏱️ Time: O(2ⁿ) Space: O(n)

Try every possible combination of accelerate and reverse instructions using recursive backtracking. For each position, try both 'A' and 'R' operations until we reach the target position.

Memoization - Cache Results

⏱️ Time: O(T × log T) Space: O(T × log T)

Optimize the brute force approach by caching results for each (position, speed) state. This prevents redundant calculations when the same state is reached through different paths.

BFS - Shortest Path — Algorithm Steps

Start BFS from (position=0, speed=1)
For each state, generate next states using A and R operations
Use queue to process states level by level
Return steps when target position is first reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 0

Start at (0,1)

Level 1

Explore (1,2) and (0,-1)

Level 2

Find target at (3,4)

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_QUEUE 500000
#define HASH_SIZE 200000
typedef struct {
    int pos, speed, steps;
} State;
typedef struct Node {
    char key[50];
    struct Node* next;
} Node;
static Node* hash_table[HASH_SIZE];
static State queue[MAX_QUEUE];
static int front = 0, rear = 0;
int hash_func(const char* key) {
    unsigned int hash = 0;
    for (int i = 0; key[i]; i++) {
        hash = hash * 31 + (unsigned char)key[i];
    }
    return hash % HASH_SIZE;
}
int contains(const char* key) {
    int idx = hash_func(key);
    Node* curr = hash_table[idx];
    while (curr) {
        if (strcmp(curr->key, key) == 0) {
            return 1;
        }
        curr = curr->next;
    }
    return 0;
}
void insert(const char* key) {
    if (contains(key)) return;
    int idx = hash_func(key);
    Node* new_node = (Node*)malloc(sizeof(Node));
    strcpy(new_node->key, key);
    new_node->next = hash_table[idx];
    hash_table[idx] = new_node;
}
int abs_val(int x) {
    return x < 0 ? -x : x;
}
void cleanup() {
    for (int i = 0; i < HASH_SIZE; i++) {
        Node* curr = hash_table[i];
        while (curr) {
            Node* temp = curr;
            curr = curr->next;
            free(temp);
        }
        hash_table[i] = NULL;
    }
}
int solution(int target) {
    if (target == 1) {
        return 1;
    }
    
    cleanup();
    front = rear = 0;
    
    queue[rear++] = (State){0, 1, 0};
    insert("0,1");
    
    while (front < rear) {
        State curr = queue[front++];
        
        // Try accelerate
        int newPos = curr.pos + curr.speed;
        int newSpeed = curr.speed * 2;
        if (newPos == target) {
            cleanup();
            return curr.steps + 1;
        }
        
        char key1[50];
        sprintf(key1, "%d,%d", newPos, newSpeed);
        if (!contains(key1) && newPos >= -target && newPos <= 2 * target && abs_val(newSpeed) <= 2 * target && rear < MAX_QUEUE) {
            insert(key1);
            queue[rear++] = (State){newPos, newSpeed, curr.steps + 1};
        }
        
        // Try reverse
        int newSpeed2 = curr.speed > 0 ? -1 : 1;
        char key2[50];
        sprintf(key2, "%d,%d", curr.pos, newSpeed2);
        if (!contains(key2) && rear < MAX_QUEUE) {
            insert(key2);
            queue[rear++] = (State){curr.pos, newSpeed2, curr.steps + 1};
        }
    }
    
    cleanup();
    return -1;
}
int main() {
    int target;
    scanf("%d", &target);
    printf("%d\n", solution(target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(T × log T)

BFS visits each unique (position, speed) state once, bounded by target range

✓ Linear Growth

Space Complexity

O(T × log T)

Queue and visited set store states, each state takes constant space

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS - Shortest Path — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler