Minimum Path Sum

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

                                            
class Solution {
    public int minPathSum(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        
        int[][] dp = new int[m][n];
        dp[0][0] = grid[0][0];
        
        for (int i = 1; i < m; i++) {
            dp[i][0] = dp[i-1][0] + grid[i][0];
        }
        
        for (int j = 1; j < n; j++) {
            dp[0][j] = dp[0][j-1] + grid[0][j];
        }
        
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + grid[i][j];
            }
        }
        
        return dp[m-1][n-1];
    }
}

                                            
class Solution(object):
    def minPathSum(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: int
        """
        m = len(grid)
        n = len(grid[0])
        
        dp = [[0 for _ in range(n)] for _ in range(m)]
        
        dp[0][0] = grid[0][0]
        
        for i in range(1, m):
            dp[i][0] = dp[i-1][0] + grid[i][0]
        
        for j in range(1, n):
            dp[0][j] = dp[0][j-1] + grid[0][j]
        
        for i in range(1, m):
            for j in range(1, n):
                dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]
        
        return dp[m-1][n-1]

                                            
int minPathSum(int** grid, int gridSize, int* gridColSize) {
    int m = gridSize;
    int n = *gridColSize;
    
    for (int i = 1; i < m; i++) {
        grid[i][0] += grid[i - 1][0];
    }
    
    for (int j = 1; j < n; j++) {
        grid[0][j] += grid[0][j - 1];
    }
    
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            grid[i][j] += fmin(grid[i - 1][j], grid[i][j - 1]);
        }
    }
    
    return grid[m - 1][n - 1];
}

                                            
public class Solution {
    public int MinPathSum(int[][] grid) {
        int m = grid.Length;
        int n = grid[0].Length;
        
        int[][] dp = new int[m][];
        for (int i = 0; i < m; i++) {
            dp[i] = new int[n];
        }
        
        dp[0][0] = grid[0][0];
        
        for (int i = 1; i < m; i++) {
            dp[i][0] = dp[i - 1][0] + grid[i][0];
        }
        
        for (int j = 1; j < n; j++) {
            dp[0][j] = dp[0][j - 1] + grid[0][j];
        }
        
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = grid[i][j] + Math.Min(dp[i - 1][j], dp[i][j - 1]);
            }
        }
        
        return dp[m - 1][n - 1];
    }
}

                                            
/**
 * @param {number[][]} grid
 * @return {number}
 */
var minPathSum = function(grid) {
    const m = grid.length;
    const n = grid[0].length;
    
    for (let i = 1; i < m; i++) {
        grid[i][0] += grid[i - 1][0];
    }
    
    for (let j = 1; j < n; j++) {
        grid[0][j] += grid[0][j - 1];
    }
    
    for (let i = 1; i < m; i++) {
        for (let j = 1; j < n; j++) {
            grid[i][j] += Math.min(grid[i - 1][j], grid[i][j - 1]);
        }
    }
    
    return grid[m - 1][n - 1];
};

                                            
function minPathSum(grid: number[][]): number {
    const m = grid.length;
    const n = grid[0].length;

    for (let i = 1; i < m; i++) {
        grid[i][0] += grid[i - 1][0];
    }

    for (let j = 1; j < n; j++) {
        grid[0][j] += grid[0][j - 1];
    }

    for (let i = 1; i < m; i++) {
        for (let j = 1; j < n; j++) {
            grid[i][j] += Math.min(grid[i - 1][j], grid[i][j - 1]);
        }
    }

    return grid[m - 1][n - 1];
};

                                            
class Solution {
    /**
     * @param Integer[][] $grid
     * @return Integer
     */
    function minPathSum($grid) {
        $m = count($grid);
        $n = count($grid[0]);
        
        for ($i = 1; $i < $m; $i++) {
            $grid[$i][0] += $grid[$i - 1][0];
        }
        
        for ($j = 1; $j < $n; $j++) {
            $grid[0][$j] += $grid[0][$j - 1];
        }
        
        for ($i = 1; $i < $m; $i++) {
            for ($j = 1; $j < $n; $j++) {
                $grid[$i][$j] += min($grid[$i - 1][$j], $grid[$i][$j - 1]);
            }
        }
        
        return $grid[$m - 1][$n - 1];
    }
}

                                            
class Solution {
    func minPathSum(_ grid: [[Int]]) -> Int {
        var dp = grid
        
        for i in 0..<grid.count {
            for j in 0..<grid[0].count {
                if i > 0 && j > 0 {
                    dp[i][j] += min(dp[i-1][j], dp[i][j-1])
                } else if i > 0 {
                    dp[i][j] += dp[i-1][j]
                } else if j > 0 {
                    dp[i][j] += dp[i][j-1]
                }
            }
        }
        
        return dp[grid.count-1][grid[0].count-1]
    }
}

                                            
class Solution {
    fun minPathSum(grid: Array<IntArray>): Int {
        val m = grid.size
        val n = grid[0].size
        
        for (i in 1 until m) {
            grid[i][0] += grid[i - 1][0]
        }
        
        for (j in 1 until n) {
            grid[0][j] += grid[0][j - 1]
        }
        
        for (i in 1 until m) {
            for (j in 1 until n) {
                grid[i][j] += minOf(grid[i - 1][j], grid[i][j - 1])
            }
        }
        
        return grid[m - 1][n - 1]
    }
}

                                            
class Solution {
  int minPathSum(List<List<int>> grid) {
    int m = grid.length;
    int n = grid[0].length;
    
    for (int i = 0; i < m; i++) {
      for (int j = 0; j < n; j++) {
        if (i == 0 && j == 0) continue;
        else if (i == 0) grid[i][j] += grid[i][j - 1];
        else if (j == 0) grid[i][j] += grid[i - 1][j];
        else grid[i][j] += grid[i - 1][j] < grid[i][j - 1] ? grid[i - 1][j] : grid[i][j - 1];
      }
    }
    
    return grid[m - 1][n - 1];
  }
}

                                            
func minPathSum(grid [][]int) int {
    m := len(grid)
    n := len(grid[0])
    
    dp := make([][]int, m)
    for i := range dp {
        dp[i] = make([]int, n)
    }
    
    dp[0][0] = grid[0][0]
    
    for i := 1; i < m; i++ {
        dp[i][0] = dp[i-1][0] + grid[i][0]
    }
    
    for j := 1; j < n; j++ {
        dp[0][j] = dp[0][j-1] + grid[0][j]
    }
    
    for i := 1; i < m; i++ {
        for j := 1; j < n; j++ {
            dp[i][j] = grid[i][j] + min(dp[i-1][j], dp[i][j-1])
        }
    }
    
    return dp[m-1][n-1]
}

func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}

                                            
# @param {Integer[][]} grid
# @return {Integer}
def min_path_sum(grid)
    m = grid.length
    n = grid[0].length
    
    (1...n).each { |j| grid[0][j] += grid[0][j-1] }
    (1...m).each { |i| grid[i][0] += grid[i-1][0] }
    
    (1...m).each do |i|
        (1...n).each do |j|
            grid[i][j] += [grid[i-1][j], grid[i][j-1]].min
        end
    end
    
    return grid[m-1][n-1]
end

                                            
object Solution {
    def minPathSum(grid: Array[Array[Int]]): Int = {
        val m = grid.length
        val n = grid(0).length
        
        for (i <- 0 until m; j <- 0 until n) {
            if (i == 0 && j == 0) {
                grid(i)(j) = grid(i)(j)
            } else if (i == 0) {
                grid(i)(j) += grid(i)(j - 1)
            } else if (j == 0) {
                grid(i)(j) += grid(i - 1)(j)
            } else {
                grid(i)(j) += math.min(grid(i - 1)(j), grid(i)(j - 1))
            }
        }
        
        grid(m - 1)(n - 1)
    }
}

                                            
impl Solution {
    pub fn min_path_sum(grid: Vec<Vec<i32>>) -> i32 {
        let m = grid.len();
        let n = grid[0].len();
        
        let mut dp = vec![vec![0; n]; m];
        dp[0][0] = grid[0][0];
        
        for i in 1..m {
            dp[i][0] = dp[i - 1][0] + grid[i][0];
        }
        
        for j in 1..n {
            dp[0][j] = dp[0][j - 1] + grid[0][j];
        }
        
        for i in 1..m {
            for j in 1..n {
                dp[i][j] = grid[i][j] + std::cmp::min(dp[i - 1][j], dp[i][j - 1]);
            }
        }
        
        dp[m - 1][n - 1]
    }
}

To solve this coding challenge, we need to find the minimum path sum from the top-left corner to the bottom-right corner of a grid of non-negative integers. This means that at each cell, we can only move either right or down until we reach the bottom-right corner, calculating the cumulative path sum in order to find the minimal one. This is a typical dynamic programming problem where we will use a 2D array to store the minimum path sums for each cell in the grid.

Explanation

The idea is to use dynamic programming to maintain a separate 2D array

dp

where

dp[i][j]

represents the minimum path sum to reach cell

(i, j)

. We will initialize the

dp

array with the same dimensions as the given grid. Here's how we approach the problem step-by-step:

Initialization:

Set
dp[0][0]

to be
grid[0][0]

since that's the starting point.

Filling the first row and first column:

For the first row, each cell
dp[0][j]

can only be reached from the left cell
dp[0][j-1]

.
For the first column, each cell
dp[i][0]

can only be reached from the cell above it
dp[i-1][0]

.

Filling the rest of the dp table:

For each other cell
(i, j)

in the grid, the cell
dp[i][j]

can be reached either from the left
(i, j-1)

or from above
(i-1, j)

. Therefore,
dp[i][j]

will be the minimum of these two possible paths plus the value of
grid[i][j]

.

Result:

The required result will be stored in
dp[m-1][n-1]

, the bottom-right cell of the
dp

table.

Pseudocode with Comments

                                            
# Function to calculate minimum path sum in a given grid
function minPathSum(grid):
# Get the number of rows (m) and columns (n) in the grid
number_of_rows = length of grid
number_of_columns = length of grid[0]

# Create a dp array with the same dimensions as the grid initialized to 0
dp = create 2D array with dimensions (number_of_rows x number_of_columns) initialized to 0

# Initialize the starting point with the value of the first cell in the grid
dp[0][0] = grid[0][0]

# Fill the first column of the dp array
for i from 1 to number_of_rows - 1:
dp[i][0] = dp[i-1][0] + grid[i][0]

# Fill the first row of the dp array
for j from 1 to number_of_columns - 1:
dp[0][j] = dp[0][j-1] + grid[0][j]

# Fill the rest of the dp array
for i from 1 to number_of_rows - 1:
for j from 1 to number_of_columns - 1:
# The value at dp[i][j] is the minimum of the value from the top and left cell
# plus the value of the current cell in the grid
dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]

# The minimum path sum to reach the bottom-right corner will be at dp[m-1][n-1]
return dp[number_of_rows - 1][number_of_columns - 1]

Step-by-Step Explanation:

Initialization of dp array:

Create a 2D array
dp

of the same size as the grid.
Initialize
dp[0][0]

with
grid[0][0]

because this is the starting point.

Populate the first column:

For each cell in the first column, add the value of the current cell in
grid

to the value of the cell directly above it in
dp

.
This handles the constraint that one can only move down when filling the first column.

Populate the first row:

Similar to the first column, for each cell in the first row, add the value of the current cell in
grid

to the value of the left cell in
dp

.
This makes sure we only move right for the first row.

Calculate the minimum path sum for the rest of the grid:

For each remaining cell
(i, j)

, calculate the minimum path sum by considering the minimum of the top
(i-1, j)

and the left
(i, j-1)

cells from
dp

.
Add the value of the current grid cell to this minimum value to get the value for
dp[i][j]

.

Return the result:

The bottom-right cell
dp[m-1][n-1]

will have the minimum path sum from the top-left to the bottom-right of the grid.

This approach ensures we optimize the path sum calculation by leveraging the already computed minimum path sums at each step in the grid.