Guess Number Higher or Lower II

Guess Number Higher or Lower II - Problem

We are playing the Guessing Game. The game will work as follows:

I pick a number between 1 and n.
You guess a number.
If you guess the right number, you win the game.
If you guess the wrong number, then I will tell you whether the number I picked is higher or lower, and you will continue guessing.
Every time you guess a wrong number x, you will pay x dollars.
If you run out of money, you lose the game.

Given a particular n, return the minimum amount of money you need to guarantee a win regardless of what number I pick.

Input & Output

Example 1 — Small Range

$ Input: n = 3

› Output: 2

💡 Note: Optimal strategy: guess 2 first. If wrong, pay 2 dollars. In worst case, still need to guess between [1,1] or [3,3] which costs 0 more. Total worst case: 2 + 0 = 2.

Example 2 — Minimum Case

$ Input: n = 1

› Output: 0

💡 Note: Only one number to guess, so no wrong guesses possible. Cost is 0.

Example 3 — Larger Range

$ Input: n = 10

› Output: 16

💡 Note: For range [1,10], optimal strategy involves guessing numbers that minimize the worst-case cost across all possible target numbers.

Constraints

1 ≤ n ≤ 200

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8 a Amazon 6

The key insight is that this is a minimax problem where we need to minimize the maximum cost over all possible target numbers. For any guess k in range [i,j], the cost is k + max(cost[i,k-1], cost[k+1,j]). The optimal approach uses dynamic programming to build solutions bottom-up. Time: O(n³), Space: O(n²).

Common Approaches

✓ Bottom-Up Dynamic Programming

⏱️ Time: O(n³) Space: O(n²)

Use a 2D DP table where dp[i][j] represents the minimum cost to guarantee a win in range [i,j]. Fill the table bottom-up by increasing range length, avoiding recursion entirely.

Memoization (Top-Down DP)

⏱️ Time: O(n³) Space: O(n²)

Same recursive approach as brute force, but store results of each [i,j] subproblem in a memoization table to avoid recalculating the same range multiple times.

Recursive Brute Force

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

For each possible guess in range [i,j], calculate the cost as the guess plus the maximum cost of the two resulting subranges. The minimum over all guesses gives the optimal strategy.

Bottom-Up Dynamic Programming — Algorithm Steps

Create 2D DP table dp[i][j]
Initialize base cases: dp[i][i] = 0
For each range length, calculate dp[i][j] using smaller subproblems
Return dp[1][n] as final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Cases

Initialize dp[i][i] = 0 (single numbers cost nothing)

Build Up

For each range length, calculate optimal cost using smaller ranges

Final Answer

dp[1][n] contains the minimum cost for the full range

Code -

solution.c — C

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

int solution(int n) {
    if (n <= 1) return 0;
    
    // dp[i][j] = minimum cost to guarantee win in range [i,j]
    int dp[n+2][n+2];
    
    // Initialize dp table
    for (int i = 0; i <= n+1; i++) {
        for (int j = 0; j <= n+1; j++) {
            dp[i][j] = 0;
        }
    }
    
    // Fill dp table by increasing range length
    for (int length = 2; length <= n; length++) {
        for (int i = 1; i <= n - length + 1; i++) {
            int j = i + length - 1;
            dp[i][j] = INT_MAX;
            
            // Try each guess k in range [i,j]
            for (int k = i; k <= j; k++) {
                int cost = k + (dp[i][k-1] > dp[k+1][j] ? dp[i][k-1] : dp[k+1][j]);
                if (cost < dp[i][j]) {
                    dp[i][j] = cost;
                }
            }
        }
    }
    
    return dp[1][n];
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: range length (n), start position (n), and guess position (n)

⚠ Quadratic Growth

Space Complexity

O(n²)

2D DP table storing results for all possible ranges [i,j]

⚠ Quadratic Space

78.2K Views

Medium Frequency

~35 min Avg. Time

1.5K 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

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler