---
title: '64. Minimum Path Sum'
description: Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right, which minimizes the sum of all numbers along its path
icon: dot
topics:
  - { name: "Array", slug: "array" }
  - { name: "Dynamic Programming", slug: "dynamic-programming" }
  - { name: "Matrix", slug: "matrix" }
issue: "https://github.com/prdlk/leetcode/issues/167"
sidebar:
  label: 'Minimum Path Sum'
  badge: 'Medium'
---

### Example 1:
- Input: `grid = [[1,3,1],[1,5,1],[4,2,1]]`
- Output: `7`
- Explanation: Because the path `1` → `3` → `1` → `1` → `1` minimizes the sum.

### Example 2:
- Input: `grid = [[1,2,3],[4,5,6]]`
- Output: `12`

### Constraints:

- `m == grid.length`
- `n == grid[i].length`
- `1 <= m, n <= 200`
- `0 <= grid[i][j] <= 200`

## Solution

```py
class Solution:
    def minPathSum(self, grid: list[list[int]]) -> int:
        if not grid or not grid[0]:
            return 0

        m = len(grid)
        n = len(grid[0])
        dp = [[0 for _ in range(n)] for _ in range(m)]

        for c in range(n):
            dp[0][c] = dp[0][c - 1] + grid[0][c] if c else grid[0][c]

        for r in range(m):
            dp[r][0] = dp[r - 1][0] + grid[r][0] if r else grid[r][0]

        for r in range(1, m):
            for c in range(1, n):
                dp[r][c] = min(dp[r - 1][c], dp[r][c - 1]) + grid[r][c]

        return dp[-1][-1]
```