[Solved] Minimum Path Cost in a Grid LeetCode Contest Problem

Minimum Path Cost in a Grid: You are given a 0-indexed m x n integer matrix grid consisting of distinct integers from 0 to m * n - 1. You can move in this matrix from a cell to any other cell in the next row. That is, if you are in cell (x, y) such that x < m - 1, you can move to any of the cells (x + 1, 0), (x + 1, 1), …, (x + 1, n - 1). Note that it is not possible to move from cells in the last row.

Each possible move has a cost given by a 0-indexed 2D array moveCost of size (m * n) x n, where moveCost[i][j] is the cost of moving from a cell with value i to a cell in column j of the next row. The cost of moving from cells in the last row of grid can be ignored.

The cost of a path in grid is the sum of all values of cells visited plus the sum of costs of all the moves made. Return the minimum cost of a path that starts from any cell in the first row and ends at any cell in the last row.

Example 1:

Input: grid = [[5,3],[4,0],[2,1]], moveCost = [[9,8],[1,5],[10,12],[18,6],[2,4],[14,3]]
Output: 17
Explanation: The path with the minimum possible cost is the path 5 -> 0 -> 1.
- The sum of the values of cells visited is 5 + 0 + 1 = 6.
- The cost of moving from 5 to 0 is 3.
- The cost of moving from 0 to 1 is 8.
So the total cost of the path is 6 + 3 + 8 = 17.

Example 2:

Input: grid = [[5,1,2],[4,0,3]], moveCost = [[12,10,15],[20,23,8],[21,7,1],[8,1,13],[9,10,25],[5,3,2]]
Output: 6
Explanation: The path with the minimum possible cost is the path 2 -> 3.
- The sum of the values of cells visited is 2 + 3 = 5.
- The cost of moving from 2 to 3 is 1.
So the total cost of this path is 5 + 1 = 6.

Constraints:

• m == grid.length
• n == grid[i].length
• 2 <= m, n <= 50
• grid consists of distinct integers from 0 to m * n - 1.
• moveCost.length == m * n
• moveCost[i].length == n
• 1 <= moveCost[i][j] <= 100

Solution:

Time Complexity: O(m*n*n)

class Solution {
public:
    int minPathCost(vector<vector<int>>& grid, vector<vector<int>>& moveCost) {
        int m=grid.size(); int n=grid[0].size();
        vector<vector<int>> dp(m,vector<int>(n));
        for(int i=0;i<n;i++) dp[m-1][i]=grid[m-1][i];
        for(int i=m-2;i>=0;i--){
            for(int j=0;j<n;j++){
            int x=100000;
           for(int k=0;k<n;k++){
                x=min(x,dp[i+1][k]+moveCost[grid[i][j]][k]);
            } 
            dp[i][j]=x+grid[i][j];
        }
        }
        int ans=100000001;
        for(int i=0;i<n;i++) ans=min(ans,dp[0][i]);
        return ans;
    }
};

class Solution:
    def minPathCost(self, grid: List[List[int]], moveCost: List[List[int]]) -> int:
        m = len(grid)
        n =len(grid[0])
        dp = [[0]*n for i in range(m)]   
        for i in range(n):
                dp[0][i] = grid[0][i]
        for i in range(1,m):
            for j in range(n):
                l = [0]*n
                for k in range(n):
                    l[k] = grid[i][j] + moveCost[grid[i-1][k]][j] + dp[i-1][k]
                dp[i][j] = min(l)
        return min(dp[-1])

class Solution {
    public int minPathCost(int[][] grid, int[][] moveCost) {
        for(int i = grid.length-2; i >= 0; i--){
            for(int j = 0; j < grid[0].length; j++){
                int min =Integer.MAX_VALUE;
                for(int z = 0; z < grid[0].length; z++){
                    min = Math.min(min, grid[i+1][z] + moveCost[ grid[i][j] ][z]);
                }
                grid[i][j] = grid[i][j] + min;
            }
        }
        int ans =Integer.MAX_VALUE;
        for(int i = 0; i < grid[0].length; i++){
            ans = Math.min(ans, grid[0][i]);
        }
        return ans;
    }
}

Happy Learning – If you require any further information, feel free to contact me.