Minimum Path Sum

class Solution {
public:
    int minPathSum(vector<vector<int>>& g) {
        int m = g.size(), n = g[0].size();
        vector<int> dp(n, INT_MAX);
        dp[0] = 0;
        for (int r = 0; r < m; ++r) {
            dp[0] += g[r][0];
            for (int c = 1; c < n; ++c) {
                dp[c] = g[r][c] + min(dp[c], dp[c - 1]);
            }
        }
        return dp[n - 1];
    }
};

func minPathSum(g [][]int) int {
    m, n := len(g), len(g[0])
    dp := make([]int, n)
    for i := range dp {
        dp[i] = math.MaxInt32
    }
    dp[0] = 0
    for r := 0; r < m; r++ {
        dp[0] += g[r][0]
        for c := 1; c < n; c++ {
            best := dp[c]
            if dp[c-1] < best {
                best = dp[c-1]
            }
            dp[c] = g[r][c] + best
        }
    }
    return dp[n-1]
}

from typing import List

class Solution:
    def minPathSum(self, g: List[List[int]]) -> int:
        m, n = len(g), len(g[0])
        dp = [float('inf')] * n
        dp[0] = 0
        for r in range(m):
            dp[0] += g[r][0]
            for c in range(1, n):
                dp[c] = g[r][c] + min(dp[c], dp[c - 1])
        return dp[n - 1]

function minPathSum(g) {
    const m = g.length, n = g[0].length;
    const dp = new Array(n).fill(Infinity);
    dp[0] = 0;
    for (let r = 0; r < m; r++) {
        dp[0] += g[r][0];
        for (let c = 1; c < n; c++) {
            dp[c] = g[r][c] + Math.min(dp[c], dp[c - 1]);
        }
    }
    return dp[n - 1];
}

class Solution {
    public int minPathSum(int[][] g) {
        int m = g.length, n = g[0].length;
        int[] dp = new int[n];
        Arrays.fill(dp, Integer.MAX_VALUE);
        dp[0] = 0;
        for (int r = 0; r < m; r++) {
            dp[0] += g[r][0];
            for (int c = 1; c < n; c++) {
                dp[c] = g[r][c] + Math.min(dp[c], dp[c - 1]);
            }
        }
        return dp[n - 1];
    }
}

function minPathSum(g: number[][]): number {
    const m = g.length, n = g[0].length;
    const dp: number[] = new Array(n).fill(Infinity);
    dp[0] = 0;
    for (let r = 0; r < m; r++) {
        dp[0] += g[r][0];
        for (let c = 1; c < n; c++) {
            dp[c] = g[r][c] + Math.min(dp[c], dp[c - 1]);
        }
    }
    return dp[n - 1];
}