Minimum Moves to Reach Target Score

Minimum Moves to Reach Target Score - Problem

Math Greedy Medium

You are playing a game with integers. You start with the integer 1 and you want to reach the integer target.

In one move, you can either:

Increment the current integer by one (i.e., x = x + 1)
Double the current integer (i.e., x = 2 * x)

You can use the increment operation any number of times, however, you can only use the double operation at most maxDoubles times.

Given the two integers target and maxDoubles, return the minimum number of moves needed to reach target starting with 1.

Input & Output

Example 1 — Basic Case

$ Input: target = 5, maxDoubles = 0

› Output: 4

💡 Note: Since we can't double, we need 4 increment operations: 1→2→3→4→5

Example 2 — Using Doubles

$ Input: target = 19, maxDoubles = 2

› Output: 7

💡 Note: Optimal path working backwards: 19→18→9→8→4→2→1, total 6 moves. Forward: 1→2→4→8→9→18→19

Example 3 — Large Target

$ Input: target = 1000000000, maxDoubles = 30

› Output: 39

💡 Note: Use doubles optimally by working backwards, then calculate remaining increments

Constraints

1 ≤ target ≤ 10⁹
0 ≤ maxDoubles ≤ 31

Visualization

Tap to expand

Asked in

M Microsoft 15 G Google 12 a Amazon 8

The key insight is to work backwards from target to 1, making greedy choices. When target is even and doubles remain, divide by 2. Otherwise subtract 1. The optimal approach uses the optimized greedy method with early termination. Time: O(log target), Space: O(1)

Common Approaches

✓ Brute Force BFS

⏱️ Time: O(2^maxDoubles) Space: O(2^maxDoubles)

Use breadth-first search to explore all possible sequences of increment and double operations. Track the current value and remaining doubles at each state.

Greedy (Reverse Approach)

⏱️ Time: O(log target) Space: O(1)

Instead of going forward from 1 to target, work backwards from target to 1. When target is even, divide by 2 (reverse of doubling). When odd, subtract 1. This greedy approach always makes the optimal choice.

Optimized Greedy with Skip

⏱️ Time: O(log target) Space: O(1)

Enhanced version of greedy approach that optimizes the case when no doubles are left. Instead of subtracting 1 repeatedly, calculate how many moves are needed directly.

Brute Force BFS — Algorithm Steps

Start BFS from value 1 with maxDoubles available
For each state, try increment (+1) and double (*2) if doubles remain
Return moves when target is reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin at value 1 with maxDoubles available

Explore

Try both +1 and *2 operations at each step

Result

Find shortest path to target

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_QUEUE 100000

typedef struct {
    int current, doublesLeft, moves;
} State;

int solution(int target, int maxDoubles) {
    if (target == 1) return 0;
    
    State queue[MAX_QUEUE];
    int front = 0, rear = 0;
    queue[rear++] = (State){1, maxDoubles, 0};
    
    while (front < rear) {
        State state = queue[front++];
        
        if (state.current == target) return state.moves;
        
        if (state.current > target) continue;
        
        if (rear < MAX_QUEUE - 1) {
            queue[rear++] = (State){state.current + 1, state.doublesLeft, state.moves + 1};
        }
        
        if (state.doublesLeft > 0 && rear < MAX_QUEUE - 1) {
            queue[rear++] = (State){state.current * 2, state.doublesLeft - 1, state.moves + 1};
        }
    }
    
    return -1;
}

int main() {
    int target, maxDoubles;
    scanf("%d", &target);
    scanf("%d", &maxDoubles);
    printf("%d\n", solution(target, maxDoubles));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^maxDoubles)

Each double operation branches into two possibilities, creating exponential states

✓ Linear Growth

Space Complexity

O(2^maxDoubles)

Queue stores exponential number of states in BFS

✓ Linear Space

32.0K Views

Medium Frequency

~15 min Avg. Time

896 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

Brute Force BFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler