LeetCode 0375. Guess Number Higher or Lower II Solution in Java, C++, Python & More | Explanation + Code

Description

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

1. I pick a number between 1 and n.
2. You guess a number.
3. If you guess the right number, you win the game.
4. 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.
5. 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.

 

Example 1:

Input: n = 10
Output: 16
Explanation: The winning strategy is as follows:
- The range is [1,10]. Guess 7.
    - If this is my number, your total is 0. Otherwise, you pay7.
    - If my number is higher, the range is [8,10]. Guess 9.
        - If this is my number, your total is 7. Otherwise, you pay9.
        - If my number is higher, it must be 10. Guess 10. Your total is 7 +9 = $16.
        - If my number is lower, it must be 8. Guess 8. Your total is 7 +9 = $16.
    - If my number is lower, the range is [1,6]. Guess 3.
        - If this is my number, your total is 7. Otherwise, you pay3.
        - If my number is higher, the range is [4,6]. Guess 5.
            - If this is my number, your total is 7 +3 = 10. Otherwise, you pay5.
            - If my number is higher, it must be 6. Guess 6. Your total is 7 +3 + 5 =15.
            - If my number is lower, it must be 4. Guess 4. Your total is 7 +3 + 5 =15.
        - If my number is lower, the range is [1,2]. Guess 1.
            - If this is my number, your total is 7 +3 = 10. Otherwise, you pay1.
            - If my number is higher, it must be 2. Guess 2. Your total is 7 +3 + 1 =11.
The worst case in all these scenarios is that you pay 16. Hence, you only need16 to guarantee a win.

Example 2:

Input: n = 1
Output: 0
Explanation: There is only one possible number, so you can guess 1 and not have to pay anything.

Example 3:

Input: n = 2
Output: 1
Explanation: There are two possible numbers, 1 and 2.
- Guess 1.
    - If this is my number, your total is 0. Otherwise, you pay1.
    - If my number is higher, it must be 2. Guess 2. Your total is $1.
The worst case is that you pay $1.

 

Constraints:

• 1 <= n <= 200

Solutions

Solution 1: Dynamic Programming

We define f[i][j] as the minimum cost required to guess any number in the interval [i, j]. Initially, f[i][i] = 0 because there is no cost to guess the only number, and for i > j, we also have f[i][j] = 0. The answer is f[1][n].

For f[i][j], we can enumerate any number k in [i, j], divide the interval [i, j] into two parts, [i, k - 1] and [k + 1, j], choose the larger value of the two parts plus the cost of k,

PythonJavaC++GoTypeScript

class Solution: def getMoneyAmount(self, n: int) -> int: f = [[0] * (n + 1) for _ in range(n + 1)] for i in range(n - 1, 0, -1): for j in range(i + 1, n + 1): f[i][j] = j + f[i][j - 1] for k in range(i, j): f[i][j] = min(f[i][j], max(f[i][k - 1], f[k + 1][j]) + k) return f[1][n](code-box)

class Solution { public int getMoneyAmount(int n) { int[][] f = new int[n + 1][n + 1]; for (int i = n - 1; i > 0; --i) { for (int j = i + 1; j <= n; ++j) { f[i][j] = j + f[i][j - 1]; for (int k = i; k < j; ++k) { f[i][j] = Math.min(f[i][j], Math.max(f[i][k - 1], f[k + 1][j]) + k); } } } return f[1][n]; } }(code-box)

class Solution { public: int getMoneyAmount(int n) { int f[n + 1][n + 1]; memset(f, 0, sizeof(f)); for (int i = n - 1; i; --i) { for (int j = i + 1; j <= n; ++j) { f[i][j] = j + f[i][j - 1]; for (int k = i; k < j; ++k) { f[i][j] = min(f[i][j], max(f[i][k - 1], f[k + 1][j]) + k); } } } return f[1][n]; } };(code-box)

func getMoneyAmount(n int) int { f := make([][]int, n+1) for i := range f { f[i] = make([]int, n+1) } for i := n - 1; i > 0; i-- { for j := i + 1; j <= n; j++ { f[i][j] = j + f[i][j-1] for k := i; k < j; k++ { f[i][j] = min(f[i][j], k+max(f[i][k-1], f[k+1][j])) } } } return f[1][n] }(code-box)

function getMoneyAmount(n: number): number { const f: number[][] = Array.from({ length: n + 1 }, () => Array(n + 1).fill(0)); for (let i = n - 1; i; --i) { for (let j = i + 1; j <= n; ++j) { f[i][j] = j + f[i][j - 1]; for (let k = i; k < j; ++k) { f[i][j] = Math.min(f[i][j], k + Math.max(f[i][k - 1], f[k + 1][j])); } } } return f[1][n]; }(code-box)