Guess Number Higher or Lower II

// Accepted solution for LeetCode #375: Guess Number Higher or Lower II
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];
    }
}

// Accepted solution for LeetCode #375: Guess Number Higher or Lower II
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]
}

# Accepted solution for LeetCode #375: Guess Number Higher or Lower II
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]

// Accepted solution for LeetCode #375: Guess Number Higher or Lower II
struct Solution;
use std::collections::HashMap;

impl Solution {
    fn get_money_amount(n: i32) -> i32 {
        let mut memo: HashMap<(i32, i32), i32> = HashMap::new();
        Self::dp(1, n, &mut memo)
    }

    fn dp(left: i32, right: i32, memo: &mut HashMap<(i32, i32), i32>) -> i32 {
        if left == right {
            0
        } else {
            if let Some(&res) = memo.get(&(left, right)) {
                return res;
            }
            let mut res = std::i32::MAX;
            for i in left..right {
                let a = if i != left {
                    Self::dp(left, i - 1, memo)
                } else {
                    0
                };
                let b = if i != right {
                    Self::dp(i + 1, right, memo)
                } else {
                    0
                };
                res = res.min(i + a.max(b));
            }
            memo.insert((left, right), res);
            res
        }
    }
}

#[test]
fn test() {
    let n = 10;
    let res = 16;
    assert_eq!(Solution::get_money_amount(n), res);
}

// Accepted solution for LeetCode #375: Guess Number Higher or Lower II
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];
}