Min Cost Path | DP-6

Given a cost matrix cost[][] and a position (M, N) in cost[][], write a function that returns cost of minimum cost path to reach (M, N) from (0, 0). Each cell of the matrix represents a cost to traverse through that cell. The total cost of a path to reach (M, N) is the sum of all the costs on that path (including both source and destination). You can only traverse down, right and diagonally lower cells from a given cell, i.e., from a given cell (i, j), cells (i+1, j), (i, j+1), and (i+1, j+1) can be traversed. 

Note: You may assume that all costs are positive integers.

Example:

Input:

The path with minimum cost is highlighted in the following figure. The path is (0, 0) –> (0, 1) –> (1, 2) –> (2, 2). The cost of the path is 8 (1 + 2 + 2 + 3).  

Output:

Min cost path using recursion:

To solve the problem follow the below idea:

This problem has the optimal substructure property. The path to reach (m, n) must be through one of the 3 cells: (m-1, n-1) or (m-1, n) or (m, n-1). So minimum cost to reach (m, n) can be written as “minimum of the 3 cells plus cost[m][n]”.
minCost(m, n) = min (minCost(m-1, n-1), minCost(m-1, n), minCost(m, n-1)) + cost[m][n] 

Follow the below steps to solve the problem:

• If N is less than zero or M is less than zero then return Integer Maximum(Base Case)
• If M is equal to zero and N is equal to zero then return cost[M][N](Base Case)
• Return cost[M][N] + minimum of (minCost(M-1, N-1), minCost(M-1, N), minCost(M, N-1))

Below is the implementation of the above approach:

C++

// A Naive recursive implementation
// of MCP(Minimum Cost Path) problem
#include <bits/stdc++.h>
using namespace std;

#define R 3
#define C 3

int min(int x, int y, int z);

// Returns cost of minimum cost path
// from (0,0) to (m, n) in mat[R][C]
int minCost(int cost[R][C], int m, int n)
{
    if (n < 0 || m < 0)
        return INT_MAX;
    else if (m == 0 && n == 0)
        return cost[m][n];
    else
        return cost[m][n]
               + min(minCost(cost, m - 1, n - 1),
                     minCost(cost, m - 1, n),
                     minCost(cost, m, n - 1));
}

// A utility function that returns
// minimum of 3 integers
int min(int x, int y, int z)
{
    if (x < y)
        return (x < z) ? x : z;
    else
        return (y < z) ? y : z;
}

// Driver code
int main()
{
    int cost[R][C]
        = { { 1, 2, 3 }, { 4, 8, 2 }, { 1, 5, 3 } };

    cout << minCost(cost, 2, 2) << endl;

    return 0;
}

// This code is contributed by nikhilchhipa9

C

/* A Naive recursive implementation of MCP(Minimum Cost
 * Path) problem */
#include <limits.h>
#include <stdio.h>
#define R 3
#define C 3

int min(int x, int y, int z);

/* Returns cost of minimum cost path from (0,0) to (m, n) in
 * mat[R][C]*/
int minCost(int cost[R][C], int m, int n)
{
    if (n < 0 || m < 0)
        return INT_MAX;
    else if (m == 0 && n == 0)
        return cost[m][n];
    else
        return cost[m][n]
               + min(minCost(cost, m - 1, n - 1),
                     minCost(cost, m - 1, n),
                     minCost(cost, m, n - 1));
}

/* A utility function that returns minimum of 3 integers */
int min(int x, int y, int z)
{
    if (x < y)
        return (x < z) ? x : z;
    else
        return (y < z) ? y : z;
}

/* Driver code */
int main()
{
    int cost[R][C]
        = { { 1, 2, 3 }, { 4, 8, 2 }, { 1, 5, 3 } };
    printf(" %d ", minCost(cost, 2, 2));
    return 0;
}

Java

/* A Naive recursive implementation of
MCP(Minimum Cost Path) problem */
public class GFG {

    /* A utility function that returns
    minimum of 3 integers */
    static int min(int x, int y, int z)
    {
        if (x < y)
            return (x < z) ? x : z;
        else
            return (y < z) ? y : z;
    }

    /* Returns cost of minimum cost path
    from (0,0) to (m, n) in mat[R][C]*/
    static int minCost(int cost[][], int m, int n)
    {
        if (n < 0 || m < 0)
            return Integer.MAX_VALUE;
        else if (m == 0 && n == 0)
            return cost[m][n];
        else
            return cost[m][n]
                + min(minCost(cost, m - 1, n - 1),
                      minCost(cost, m - 1, n),
                      minCost(cost, m, n - 1));
    }

    // Driver code
    public static void main(String args[])
    {

        int cost[][]
            = { { 1, 2, 3 }, { 4, 8, 2 }, { 1, 5, 3 } };

        System.out.print(minCost(cost, 2, 2));
    }
}

// This code is contributed by Sam007

Python3

# A Naive recursive implementation of MCP(Minimum Cost Path) problem
import sys
R = 3
C = 3

# Returns cost of minimum cost path from (0,0) to (m, n) in mat[R][C]


def minCost(cost, m, n):
    if (n < 0 or m < 0):
        return sys.maxsize
    elif (m == 0 and n == 0):
        return cost[m][n]
    else:
        return cost[m][n] + min(minCost(cost, m-1, n-1),
                                minCost(cost, m-1, n),
                                minCost(cost, m, n-1))

# A utility function that returns minimum of 3 integers */


def min(x, y, z):
    if (x < y):
        return x if (x < z) else z
    else:
        return y if (y < z) else z


# Driver code
cost = [[1, 2, 3],
        [4, 8, 2],
        [1, 5, 3]]
print(minCost(cost, 2, 2))

# This code is contributed by
# Smitha Dinesh Semwal

C#

/* A Naive recursive implementation of
MCP(Minimum Cost Path) problem */
using System;

class GFG {

    /* A utility function that
    returns minimum of 3 integers */
    static int min(int x, int y, int z)
    {
        if (x < y)
            return ((x < z) ? x : z);
        else
            return ((y < z) ? y : z);
    }

    /* Returns cost of minimum
    cost path from (0,0) to
    (m, n) in mat[R][C]*/
    static int minCost(int[, ] cost, int m, int n)
    {
        if (n < 0 || m < 0)
            return int.MaxValue;
        else if (m == 0 && n == 0)
            return cost[m, n];
        else
            return cost[m, n]
                + min(minCost(cost, m - 1, n - 1),
                      minCost(cost, m - 1, n),
                      minCost(cost, m, n - 1));
    }

    // Driver code
    public static void Main()
    {

        int[, ] cost
            = { { 1, 2, 3 }, { 4, 8, 2 }, { 1, 5, 3 } };

        Console.Write(minCost(cost, 2, 2));
    }
}

// This code is contributed
// by shiv_bhakt.

Javascript

<script>

// A Naive recursive implementation of
// MCP(Minimum Cost Path) problem

// A utility function that returns
// minimum of 3 integers
function min(x, y, z)
{
    if (x < y)
        return (x < z) ? x : z;
    else
        return (y < z) ? y : z;
}

// Returns cost of minimum cost path
// from (0,0) to (m, n) in mat[R][C]
function minCost(cost, m, n)
{
    if (n < 0 || m < 0)
        return Number.MAX_VALUE;
    else if (m == 0 && n == 0)
        return cost[m][n];
    else
        return cost[m][n] + min(minCost(cost, m - 1, n - 1),
                                minCost(cost, m - 1, n),
                                minCost(cost, m, n - 1));
}

// Driver code
var cost = [ [ 1, 2, 3 ],
             [ 4, 8, 2 ],
             [ 1, 5, 3 ] ];

document.write(minCost(cost, 2, 2));

// This code is contributed by gauravrajput1

</script>

PHP

<?php
/* A Naive recursive implementation
of MCP(Minimum Cost Path) problem */

$R = 3;
$C = 3;


/* Returns cost of minimum
cost path from (0,0) to
(m, n) in mat[R][C]*/
function minCost($cost, $m, $n)
{
global $R;
global $C;
if ($n < 0 || $m < 0)
    return PHP_INT_MAX;
else if ($m == 0 && $n == 0)
    return $cost[$m][$n];
else
    return $cost[$m][$n] +
            min1(minCost($cost, $m - 1, $n - 1),
            minCost($cost, $m - 1, $n),
            minCost($cost, $m, $n - 1) );
}

/* A utility function that
returns minimum of 3 integers */
function min1($x, $y, $z)
{
if ($x < $y)
    return ($x < $z)? $x : $z;
else
    return ($y < $z)? $y : $z;
}

// Driver Code
$cost = array(array(1, 2, 3),
              array (4, 8, 2),
              array (1, 5, 3));
echo minCost($cost, 2, 2);

// This code is contributed by mits.
?>

Output

 8

Time Complexity: O((M * N)³)
Auxiliary Space: O(M + N), for recursive stack space

Min cost path using Memoization DP:

To convert the given recursive implementation to a memoized version, use an auxiliary table to store the already computed values.
An additional 2D array memo is introduced to store the computed values. Initially, all entries of memo are set to -1 using the memset function. The minCostMemoized function is recursively called, and before making a recursive call, it checks if the value has already been computed by checking the corresponding entry in the memo table. If the value is found in the memo table, it is directly returned. Otherwise, the value is computed, stored in the memo table, and returned.

This memoized version will avoid redundant recursive calls and greatly improve the efficiency of the algorithm by storing and reusing previously computed values.

C++

// A Dynamic Programming based
// solution for MCP problem
#include <bits/stdc++.h>
using namespace std;

#define R 3
#define C 3

int min(int x, int y, int z);

// Returns cost of minimum cost path
// from (0,0) to (m, n) in mat[R][C]
int minCostMemoized(int cost[R][C], int m, int n,
                    int memo[R][C])
{
    if (n < 0 || m < 0)
        return INT_MAX;
    else if (m == 0 && n == 0)
        return cost[m][n];

    if (memo[m][n] != -1)
        return memo[m][n];

    memo[m][n]
        = cost[m][n]
          + min(minCostMemoized(cost, m - 1, n - 1, memo),
                minCostMemoized(cost, m - 1, n, memo),
                minCostMemoized(cost, m, n - 1, memo));

    return memo[m][n];
}

// Returns cost of minimum cost path
// from (0,0) to (m, n) in mat[R][C]
int minCost(int cost[R][C], int m, int n)
{
    int memo[R][C];
    memset(memo, -1,
           sizeof(memo)); // Initialize memo table with -1

    return minCostMemoized(cost, m, n, memo);
}

// A utility function that returns
// minimum of 3 integers
int min(int x, int y, int z)
{
    if (x < y)
        return (x < z) ? x : z;
    else
        return (y < z) ? y : z;
}

// Driver code
int main()
{
    int cost[R][C]
        = { { 1, 2, 3 }, { 4, 8, 2 }, { 1, 5, 3 } };

    cout << minCost(cost, 2, 2) << endl;

    return 0;
}

Java

import java.util.Arrays;

public class MinimumCostPath {

    // Define the number of rows and columns
    static final int R = 3;
    static final int C = 3;

    // Utility function to find the minimum of three integers
    public static int min(int x, int y, int z) {
        if (x < y)
            return (x < z) ? x : z;
        else
            return (y < z) ? y : z;
    }

    // Recursive function to find the minimum cost path using memoization
    public static int minCostMemoized(int[][] cost, int m, int n, int[][] memo) {
        // Base case: if out of bounds, return a large value (to be ignored)
        if (n < 0 || m < 0)
            return Integer.MAX_VALUE;
        // Base case: if at the top-left corner, return the cost at that cell
        else if (m == 0 && n == 0)
            return cost[m][n];

        // Check if the result is already memoized
        if (memo[m][n] != -1)
            return memo[m][n];

        // Calculate the minimum cost to reach the current cell
        memo[m][n] = cost[m][n]
                + min(minCostMemoized(cost, m - 1, n - 1, memo),
                      minCostMemoized(cost, m - 1, n, memo),
                      minCostMemoized(cost, m, n - 1, memo));

        // Return the minimum cost
        return memo[m][n];
    }

    // Function to find the minimum cost path from (0, 0) to (m, n)
    public static int minCost(int[][] cost, int m, int n) {
        // Create a memoization table to store intermediate results
        int[][] memo = new int[R][C];
        for (int[] row : memo)
            Arrays.fill(row, -1); // Initialize memo table with -1

        // Call the memoized function to find the minimum cost
        return minCostMemoized(cost, m, n, memo);
    }

    public static void main(String[] args) {
        // Cost matrix for the grid
        int[][] cost = { { 1, 2, 3 }, { 4, 8, 2 }, { 1, 5, 3 } };

        // Calculate and print the minimum cost path from (0, 0) to (2, 2)
        System.out.println(minCost(cost, 2, 2));
    }
}

Python3

R = 3
C = 3

# Returns cost of minimum cost path
# from (0,0) to (m, n) in mat[R][C]
def min_cost_memoized(cost, m, n, memo):
    if n < 0 or m < 0:
        return float('inf')
    elif m == 0 and n == 0:
        return cost[m][n]

    if memo[m][n] != -1:
        return memo[m][n]

    memo[m][n] = cost[m][n] + min(
        min_cost_memoized(cost, m - 1, n - 1, memo),
        min_cost_memoized(cost, m - 1, n, memo),
        min_cost_memoized(cost, m, n - 1, memo)
    )

    return memo[m][n]

# Returns cost of minimum cost path
# from (0,0) to (m, n) in mat[R][C]
def min_cost(cost, m, n):
    memo = [[-1] * C for _ in range(R)]  # Initialize memo table with -1

    return min_cost_memoized(cost, m, n, memo)

# Driver code
cost = [
    [1, 2, 3],
    [4, 8, 2],
    [1, 5, 3]
]

print(min_cost(cost, 2, 2))

C#

using System;

class Program {
    const int R = 3;
    const int C = 3;

    // Returns cost of minimum cost path
    // from (0,0) to (m, n) in mat[R][C]
    static int MinCostMemoized(int[][] cost, int m, int n,
                               int[][] memo)
    {
        if (n < 0 || m < 0)
            return int.MaxValue;
        else if (m == 0 && n == 0)
            return cost[m][n];

        if (memo[m][n] != -1)
            return memo[m][n];

        memo[m][n]
            = cost[m][n]
              + Math.Min(
                  Math.Min(MinCostMemoized(cost, m - 1,
                                           n - 1, memo),
                           MinCostMemoized(cost, m - 1, n,
                                           memo)),
                  MinCostMemoized(cost, m, n - 1, memo));

        return memo[m][n];
    }

    // Returns cost of minimum cost path
    // from (0,0) to (m, n) in mat[R][C]
    static int MinCost(int[][] cost, int m, int n)
    {
        int[][] memo = new int[R][];
        for (int i = 0; i < R; i++) {
            memo[i] = new int[C];
            for (int j = 0; j < C; j++) {
                memo[i][j] = -1;
            }
        }

        return MinCostMemoized(cost, m, n, memo);
    }

    // A utility function that returns
    // minimum of 3 integers
    static int Min(int x, int y, int z)
    {
        if (x < y)
            return (x < z) ? x : z;
        else
            return (y < z) ? y : z;
    }

    // Driver code
    static void Main(string[] args)
    {
        int[][] cost
            = new int[][] { new int[] { 1, 2, 3 },
                            new int[] { 4, 8, 2 },
                            new int[] { 1, 5, 3 } };

        Console.WriteLine(MinCost(cost, 2, 2));

        // Output: 8
    }
}

Javascript

const R = 3;
const C = 3;

// Helper function to find the minimum of three integers
function min(x, y, z) {
    return (x < y) ? (x < z ? x : z) : (y < z ? y : z);
}

// Function to calculate the minimum cost path using memoization
function minCostMemoized(cost, m, n, memo) {
    // Base case: if we're outside the grid, return a large value
    if (n < 0 || m < 0) {
        return Number.MAX_SAFE_INTEGER;
    }
    // Base case: if we're at the top-left cell, return its cost
    else if (m === 0 && n === 0) {
        return cost[m][n];
    }

    // If the result is already computed, return it
    if (memo[m][n] !== -1) {
        return memo[m][n];
    }

    // Calculate the cost for the current cell and store it in the memo table
    memo[m][n] = cost[m][n] + min(
        minCostMemoized(cost, m - 1, n - 1, memo),  // Diagonal
        minCostMemoized(cost, m - 1, n, memo),      // Up
        minCostMemoized(cost, m, n - 1, memo)       // Left
    );

    return memo[m][n];
}

// Function to find the minimum cost path from (0,0) to (m, n)
function minCost(cost, m, n) {
    // Initialize a memoization table filled with -1
    const memo = new Array(R).fill().map(() => new Array(C).fill(-1));

    // Call the memoized function to compute the result
    return minCostMemoized(cost, m, n, memo);
}

// Input matrix of costs
const cost = [
    [1, 2, 3],
    [4, 8, 2],
    [1, 5, 3]
];

// Calculate and print the minimum cost path
console.log(minCost(cost, 2, 2));

Time Complexity: O(M * N)
Auxiliary Space: O(M * N)

Min cost path using Dynamic Programming:

To solve the problem follow the below idea:

It should be noted that the above function computes the same subproblems again and again. See the following recursion tree, there are many nodes which appear more than once. The time complexity of this naive recursive solution is exponential and it is terribly slow. 

mC refers to minCost()
                                    mC(2, 2)
                          /            |           \
                         /             |            \             
                 mC(1, 1)           mC(1, 2)             mC(2, 1)
              /     |     \       /     |     \           /     |     \ 
             /      |      \     /      |      \         /      |       \
       mC(0,0) mC(0,1) mC(1,0) mC(0,1) mC(0,2) mC(1,1) mC(1,0) mC(1,1) mC(2,0)

So the MCP problem has both properties (see this and this) of a dynamic programming problem. Like other typical Dynamic Programming(DP) problems, recomputations of the same subproblems can be avoided by constructing a temporary array tc[][] in a bottom-up manner.

Follow the below steps to solve the problem:

• Create a 2-D array ‘tc’ of size R * C
• Calculate prefix sum for the first row and first column in ‘tc’ array as there is only one way to reach any cell in the first row or column
• Run a nested for loop for i [1, M] and j [1, N]
  • Set tc[i][j] equal to minimum of (tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
• Return tc[M][N]

Below is the implementation of the above approach:

C++

/* Dynamic Programming implementation of MCP problem */
#include <bits/stdc++.h>
#define R 3
#define C 3
using namespace std;

int min(int x, int y, int z);

int minCost(int cost[R][C], int m, int n)
{
    int i, j;

    // Instead of following line, we can use int
    // tc[m+1][n+1] or dynamically allocate memory to save
    // space. The following line is used to keep the program
    // simple and make it working on all compilers.
    int tc[R][C];

    tc[0][0] = cost[0][0];

    /* Initialize first column of total cost(tc) array */
    for (i = 1; i <= m; i++)
        tc[i][0] = tc[i - 1][0] + cost[i][0];

    /* Initialize first row of tc array */
    for (j = 1; j <= n; j++)
        tc[0][j] = tc[0][j - 1] + cost[0][j];

    /* Construct rest of the tc array */
    for (i = 1; i <= m; i++)
        for (j = 1; j <= n; j++)
            tc[i][j] = min(tc[i - 1][j - 1], tc[i - 1][j],
                           tc[i][j - 1])
                       + cost[i][j];

    return tc[m][n];
}

/* A utility function that returns minimum of 3 integers */
int min(int x, int y, int z)
{
    if (x < y)
        return (x < z) ? x : z;
    else
        return (y < z) ? y : z;
}

/* Driver code*/
int main()
{
    int cost[R][C]
        = { { 1, 2, 3 }, { 4, 8, 2 }, { 1, 5, 3 } };
    cout << "  " << minCost(cost, 2, 2);
    return 0;
}

// This code is contributed by shivanisinghss2110

C

/* Dynamic Programming implementation of MCP problem */
#include <limits.h>
#include <stdio.h>
#define R 3
#define C 3

int min(int x, int y, int z);

int minCost(int cost[R][C], int m, int n)
{
    int i, j;

    // Instead of following line, we can use int
    // tc[m+1][n+1] or dynamically allocate memory to save
    // space. The following line is used to keep the program
    // simple and make it working on all compilers.
    int tc[R][C];

    tc[0][0] = cost[0][0];

    /* Initialize first column of total cost(tc) array */
    for (i = 1; i <= m; i++)
        tc[i][0] = tc[i - 1][0] + cost[i][0];

    /* Initialize first row of tc array */
    for (j = 1; j <= n; j++)
        tc[0][j] = tc[0][j - 1] + cost[0][j];

    /* Construct rest of the tc array */
    for (i = 1; i <= m; i++)
        for (j = 1; j <= n; j++)
            tc[i][j] = min(tc[i - 1][j - 1], tc[i - 1][j],
                           tc[i][j - 1])
                       + cost[i][j];

    return tc[m][n];
}

/* A utility function that returns minimum of 3 integers */
int min(int x, int y, int z)
{
    if (x < y)
        return (x < z) ? x : z;
    else
        return (y < z) ? y : z;
}

/* Driver code */
int main()
{
    int cost[R][C]
        = { { 1, 2, 3 }, { 4, 8, 2 }, { 1, 5, 3 } };
    printf(" %d ", minCost(cost, 2, 2));
    return 0;
}

Java

/* Java program for Dynamic Programming implementation
   of Min Cost Path problem */
import java.util.*;

class MinimumCostPath {
    /* A utility function that returns minimum of 3 integers
     */
    private static int min(int x, int y, int z)
    {
        if (x < y)
            return (x < z) ? x : z;
        else
            return (y < z) ? y : z;
    }

    private static int minCost(int cost[][], int m, int n)
    {
        int i, j;
        int tc[][] = new int[m + 1][n + 1];

        tc[0][0] = cost[0][0];

        /* Initialize first column of total cost(tc) array
         */
        for (i = 1; i <= m; i++)
            tc[i][0] = tc[i - 1][0] + cost[i][0];

        /* Initialize first row of tc array */
        for (j = 1; j <= n; j++)
            tc[0][j] = tc[0][j - 1] + cost[0][j];

        /* Construct rest of the tc array */
        for (i = 1; i <= m; i++)
            for (j = 1; j <= n; j++)
                tc[i][j] = min(tc[i - 1][j - 1],
                               tc[i - 1][j], tc[i][j - 1])
                           + cost[i][j];

        return tc[m][n];
    }

    /* Driver code */
    public static void main(String args[])
    {
        int cost[][]
            = { { 1, 2, 3 }, { 4, 8, 2 }, { 1, 5, 3 } };
        System.out.println(minCost(cost, 2, 2));
    }
}
// This code is contributed by Pankaj Kumar

Python

# Dynamic Programming Python implementation of Min Cost Path
# problem
R = 3
C = 3


def minCost(cost, m, n):

    # Instead of following line, we can use int tc[m+1][n+1] or
    # dynamically allocate memoery to save space. The following
    # line is used to keep te program simple and make it working
    # on all compilers.
    tc = [[0 for x in range(C)] for x in range(R)]

    tc[0][0] = cost[0][0]

    # Initialize first column of total cost(tc) array
    for i in range(1, m+1):
        tc[i][0] = tc[i-1][0] + cost[i][0]

    # Initialize first row of tc array
    for j in range(1, n+1):
        tc[0][j] = tc[0][j-1] + cost[0][j]

    # Construct rest of the tc array
    for i in range(1, m+1):
        for j in range(1, n+1):
            tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]

    return tc[m][n]


# Driver code
cost = [[1, 2, 3],
        [4, 8, 2],
        [1, 5, 3]]
print(minCost(cost, 2, 2))

# This code is contributed by Bhavya Jain

C#

// C# program for Dynamic Programming implementation
// of Min Cost Path problem
using System;

class GFG {
    // A utility function that
    // returns minimum of 3 integers
    private static int min(int x, int y, int z)
    {
        if (x < y)
            return (x < z) ? x : z;
        else
            return (y < z) ? y : z;
    }

    private static int minCost(int[, ] cost, int m, int n)
    {
        int i, j;
        int[, ] tc = new int[m + 1, n + 1];

        tc[0, 0] = cost[0, 0];

        /* Initialize first column of total cost(tc) array
         */
        for (i = 1; i <= m; i++)
            tc[i, 0] = tc[i - 1, 0] + cost[i, 0];

        /* Initialize first row of tc array */
        for (j = 1; j <= n; j++)
            tc[0, j] = tc[0, j - 1] + cost[0, j];

        /* Construct rest of the tc array */
        for (i = 1; i <= m; i++)
            for (j = 1; j <= n; j++)
                tc[i, j] = min(tc[i - 1, j - 1],
                               tc[i - 1, j], tc[i, j - 1])
                           + cost[i, j];

        return tc[m, n];
    }

    // Driver code
    public static void Main()
    {
        int[, ] cost
            = { { 1, 2, 3 }, { 4, 8, 2 }, { 1, 5, 3 } };
        Console.Write(minCost(cost, 2, 2));
    }
}

// This code is contributed by Sam007.

Javascript

<script>
    // Javascript program for Dynamic Programming implementation
    // of Min Cost Path problem

    /* A utility function that returns minimum of 3 integers */
    function min(x, y, z)
    {
        if (x < y)
            return (x < z)? x : z;
        else
            return (y < z)? y : z;
    }

    function minCost(cost, m, n)
    {
        let i, j;
        let tc = new Array(m+1);

        for(let k = 0; k < m + 1; k++)
        {
            tc[k] = new Array(n+1);
        }

        tc[0][0] = cost[0][0];

        /* Initialize first column of total cost(tc) array */
        for (i = 1; i <= m; i++)
            tc[i][0] = tc[i-1][0] + cost[i][0];

        /* Initialize first row of tc array */
        for (j = 1; j <= n; j++)
            tc[0][j] = tc[0][j-1] + cost[0][j];

        /* Construct rest of the tc array */
        for (i = 1; i <= m; i++)
            for (j = 1; j <= n; j++)
                tc[i][j] = Math.min(tc[i-1][j-1],
                               tc[i-1][j],
                               tc[i][j-1]) + cost[i][j];

        return tc[m][n];
    }

    let cost = [[1, 2, 3],
                [4, 8, 2],
                 [1, 5, 3]];
    document.write(minCost(cost,2,2));

</script>

PHP

<?php
// DP implementation
// of MCP problem
$R = 3;
$C = 3;

function minCost($cost, $m, $n)
{
    global $R;
    global $C;
    // Instead of following line,
    // we can use int tc[m+1][n+1]
    // or dynamically allocate
    // memory to save space. The
    // following line is used to keep
    // the program simple and make
    // it working on all compilers.
    $tc;
    for ($i = 0; $i <= $R; $i++)
    for ($j = 0; $j <= $C; $j++)
    $tc[$i][$j] = 0;

    $tc[0][0] = $cost[0][0];

    /* Initialize first column of
       total cost(tc) array */
    for ($i = 1; $i <= $m; $i++)
        $tc[$i][0] = $tc[$i - 1][0] +
                     $cost[$i][0];

    /* Initialize first
       row of tc array */
    for ($j = 1; $j <= $n; $j++)
        $tc[0][$j] = $tc[0][$j - 1] +
                     $cost[0][$j];

    /* Construct rest of
       the tc array */
    for ($i = 1; $i <= $m; $i++)
        for ($j = 1; $j <= $n; $j++)

            // returns minimum of 3 integers
            $tc[$i][$j] = min($tc[$i - 1][$j - 1],
                              $tc[$i - 1][$j],
                              $tc[$i][$j - 1]) +
                              $cost[$i][$j];

    return $tc[$m][$n];
}


// Driver Code
$cost = array(array(1, 2, 3),
              array(4, 8, 2),
              array(1, 5, 3));
echo minCost($cost, 2, 2);

// This code is contributed by mits
?>

Output

 8

Time Complexity: O(M * N)
Auxiliary Space: O(M * N)

Min cost path using Dynamic Programming(Space optimized):

To solve the problem follow the below idea:

The idea is to use the same given/input array to store the solutions of subproblems in the above solution

Follow the below steps to solve the problem:

• Calculate prefix sum for the first row and first column in ‘cost’ array as there is only one way to reach any cell in the first row or column
• Run a nested for loop for i [1, M-1] and j [1, N-1]
  • Set cost[i][j] equal to minimum of (cost[i-1][j-1], cost[i-1][j], cost[i][j-1]) + cost[i][j]
• Return cost[M-1][N-1]

Below is the implementation of the above approach:

C++

// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

#define row 3
#define col 3

int minCost(int cost[row][col])
{

    // for 1st column
    for (int i = 1; i < row; i++)
        cost[i][0] += cost[i - 1][0];

    // for 1st row
    for (int j = 1; j < col; j++)
        cost[0][j] += cost[0][j - 1];

    // for rest of the 2d matrix
    for (int i = 1; i < row; i++)
        for (int j = 1; j < col; j++)
            cost[i][j]
                += min(cost[i - 1][j - 1],
                       min(cost[i - 1][j], cost[i][j - 1]));

    // returning the value in last cell
    return cost[row - 1][col - 1];
}

// Driver code
int main(int argc, char const* argv[])
{
    int cost[row][col]
        = { { 1, 2, 3 }, { 4, 8, 2 }, { 1, 5, 3 } };

    cout << minCost(cost) << endl;
    return 0;
}

// This code is contributed by Aditya Kumar (adityakumar129)

C

// C++ program for the above approach

#include <stdio.h>

#define row 3
#define col 3

// Find minimum between two numbers.
int min(int num1, int num2)
{
    return (num1 > num2) ? num2 : num1;
}

int minCost(int cost[row][col])
{
    // for 1st column
    for (int i = 1; i < row; i++)
        cost[i][0] += cost[i - 1][0];

    // for 1st row
    for (int j = 1; j < col; j++)
        cost[0][j] += cost[0][j - 1];

    // for rest of the 2d matrix
    for (int i = 1; i < row; i++)
        for (int j = 1; j < col; j++)
            cost[i][j]
                += min(cost[i - 1][j - 1],
                       min(cost[i - 1][j], cost[i][j - 1]));

    // returning the value in last cell
    return cost[row - 1][col - 1];
}

// Driver code
int main()
{
    int cost[row][col]
        = { { 1, 2, 3 }, { 4, 8, 2 }, { 1, 5, 3 } };

    printf("%d \n", minCost(cost));
    return 0;
}

// This code is contributed by Aditya Kumar (adityakumar129)

Java

// Java program for the
// above approach
import java.util.*;
class GFG {

    static int row = 3;
    static int col = 3;

    static int minCost(int cost[][])
    {
        // for 1st column
        for (int i = 1; i < row; i++) {
            cost[i][0] += cost[i - 1][0];
        }

        // for 1st row
        for (int j = 1; j < col; j++) {
            cost[0][j] += cost[0][j - 1];
        }

        // for rest of the 2d matrix
        for (int i = 1; i < row; i++) {
            for (int j = 1; j < col; j++) {
                cost[i][j]
                    += Math.min(cost[i - 1][j - 1],
                                Math.min(cost[i - 1][j],
                                         cost[i][j - 1]));
            }
        }

        // Returning the value in
        // last cell
        return cost[row - 1][col - 1];
    }

    // Driver code
    public static void main(String[] args)
    {
        int cost[][]
            = { { 1, 2, 3 }, { 4, 8, 2 }, { 1, 5, 3 } };
        System.out.print(minCost(cost) + "\n");
    }
}

// This code is contributed by Amit Katiyar

Python3

# Python3 program for the
# above approach


def minCost(cost, row, col):

    # For 1st column
    for i in range(1, row):
        cost[i][0] += cost[i - 1][0]

    # For 1st row
    for j in range(1, col):
        cost[0][j] += cost[0][j - 1]

    # For rest of the 2d matrix
    for i in range(1, row):
        for j in range(1, col):
            cost[i][j] += (min(cost[i - 1][j - 1],
                               min(cost[i - 1][j],
                                   cost[i][j - 1])))

    # Returning the value in
    # last cell
    return cost[row - 1][col - 1]


# Driver code
if __name__ == '__main__':

    row = 3
    col = 3

    cost = [[1, 2, 3],
            [4, 8, 2],
            [1, 5, 3]]

    print(minCost(cost, row, col))

# This code is contributed by Amit Katiyar

C#

// C# program for the
// above approach
using System;
class GFG {

    static int row = 3;
    static int col = 3;

    static int minCost(int[, ] cost)
    {
        // for 1st column
        for (int i = 1; i < row; i++) {
            cost[i, 0] += cost[i - 1, 0];
        }

        // for 1st row
        for (int j = 1; j < col; j++) {
            cost[0, j] += cost[0, j - 1];
        }

        // for rest of the 2d matrix
        for (int i = 1; i < row; i++) {
            for (int j = 1; j < col; j++) {
                cost[i, j]
                    += Math.Min(cost[i - 1, j - 1],
                                Math.Min(cost[i - 1, j],
                                         cost[i, j - 1]));
            }
        }

        // Returning the value in
        // last cell
        return cost[row - 1, col - 1];
    }

    // Driver code
    public static void Main(String[] args)
    {
        int[, ] cost
            = { { 1, 2, 3 }, { 4, 8, 2 }, { 1, 5, 3 } };
        Console.Write(minCost(cost) + "\n");
    }
}

// This code is contributed by Rajput-Ji

Javascript

<script>

// javascript program for the
// above approach

var row = 3;
var col = 3;

function minCost(cost)
{
  // for 1st column
  for (i = 1; i < row; i++)
  {
    cost[i][0] += cost[i - 1][0];
  }

  // for 1st row
  for (j = 1; j < col; j++)
  {
    cost[0][j] += cost[0][j - 1];
  }

  // for rest of the 2d matrix
  for (i = 1; i < row; i++)
  {
    for (j = 1; j < col; j++)
    {
      cost[i][j] += Math.min(cost[i - 1][j - 1],
                    Math.min(cost[i - 1][j],
                             cost[i][j - 1]));
    }
  }

  // Returning the value in
  // last cell
  return cost[row - 1][col - 1];
}

// Driver code
var cost = [[1, 2, 3],
[4, 8, 2],
[1, 5, 3] ];
document.write(minCost(cost) + '<br>');

// This code is contributed by 29AjayKumar

</script>

Output

8

Time Complexity: O(N * M), where N is the number of rows and M is the number of columns
Auxiliary Space: O(1), since no extra space has been taken

Min cost path using Dijkstra’s algorithm:

To solve the problem follow the below idea:

We can also use the Dijkstra’s shortest path algorithm to find the path with minimum cost

Follow the below steps to solve the problem:

• Create a 2-D dp array to store answer for each cell
• Declare a priority queue to perform dijkstra’s algorithm
• Return dp[M][N]

Below is the implementation of the approach: 

C++

/* Minimum Cost Path using Dijkstra’s shortest path
   algorithm with Min Heap by dinglizeng */
#include <bits/stdc++.h>
using namespace std;

/* define the number of rows and the number of columns */
#define R 4
#define C 5

/* 8 possible moves */
int dx[] = { 1, -1, 0, 0, 1, 1, -1, -1 };
int dy[] = { 0, 0, 1, -1, 1, -1, 1, -1 };

/* The data structure to store the coordinates of \\
  the unit square and the cost of path from the top left. */
struct Cell {
    int x;
    int y;
    int cost;
};

/* The compare class to be used by a Min Heap.
 * The greater than condition is used as this
   is for a Min Heap based on priority_queue.
 */
class mycomparison {
public:
    bool operator()(const Cell& lhs, const Cell& rhs) const
    {
        return (lhs.cost > rhs.cost);
    }
};

/* To verify whether a move is within the boundary. */
bool isSafe(int x, int y)
{
    return x >= 0 && x < R && y >= 0 && y < C;
}

/* This solution is based on Dijkstra’s shortest path
 algorithm
 * For each unit square being visited, we examine all
    possible next moves in 8 directions,
 *    calculate the accumulated cost of path for each
     next move, adjust the cost of path of the adjacent
     units to the minimum as needed.
 *    then add the valid next moves into a Min Heap.
 * The Min Heap pops out the next move with the minimum
   accumulated cost of path.
 * Once the iteration reaches the last unit at the lower
   right corner, the minimum cost path will be returned.
 */
int minCost(int cost[R][C], int m, int n)
{

    /* the array to store the accumulated cost
       of path from top left corner */
    int dp[R][C];

    /* the array to record whether a unit
       square has been visited */
    bool visited[R][C];

    /* Initialize these two arrays, set path cost
      to maximum integer value, each unit as not visited */
    for (int i = 0; i < R; i++) {
        for (int j = 0; j < C; j++) {
            dp[i][j] = INT_MAX;
            visited[i][j] = false;
        }
    }

    /* Define a reverse priority queue.
     * Priority queue is a heap based implementation.
     * The default behavior of a priority queue is
        to have the maximum element at the top.
     * The compare class is used in the definition of the
     Min Heap.
     */
    priority_queue<Cell, vector<Cell>, mycomparison> pq;

    /* initialize the starting top left unit with the
      cost and add it to the queue as the first move. */
    dp[0][0] = cost[0][0];
    pq.push({ 0, 0, cost[0][0] });

    while (!pq.empty()) {

        /* pop a move from the queue, ignore the units
           already visited */
        Cell cell = pq.top();
        pq.pop();
        int x = cell.x;
        int y = cell.y;
        if (visited[x][y])
            continue;

        /* mark the current unit as visited */
        visited[x][y] = true;

        /* examine all non-visited adjacent units in 8
         directions
         * calculate the accumulated cost of path for
           each next move from this unit,
         * adjust the cost of path for each next adjacent
           units to the minimum if possible.
         */
        for (int i = 0; i < 8; i++) {
            int next_x = x + dx[i];
            int next_y = y + dy[i];
            if (isSafe(next_x, next_y)
                && !visited[next_x][next_y]) {
                dp[next_x][next_y]
                    = min(dp[next_x][next_y],
                          dp[x][y] + cost[next_x][next_y]);
                pq.push(
                    { next_x, next_y, dp[next_x][next_y] });
            }
        }
    }

    /* return the minimum cost path at the lower
       right corner */
    return dp[m][n];
}

/* Driver code */
int main()
{
    int cost[R][C] = { { 1, 8, 8, 1, 5 },
                       { 4, 1, 1, 8, 1 },
                       { 4, 2, 8, 8, 1 },
                       { 1, 5, 8, 8, 1 } };
    printf(" %d ", minCost(cost, 3, 4));
    return 0;
}

Java

/* Minimum Cost Path using Dijkstra’s shortest path
   algorithm with Min Heap by dinglizeng */
import java.util.*;

public class GFG {
    /* define the number of rows and the number of columns
     */
    static int R = 4;
    static int C = 5;

    /* 8 possible moves */
    static int dx[] = { 1, -1, 0, 0, 1, 1, -1, -1 };
    static int dy[] = { 0, 0, 1, -1, 1, -1, 1, -1 };

    /* The data structure to store the coordinates of \\
      the unit square and the cost of path from the top
      left. */
    static class Cell {
        int x;
        int y;
        int cost;
        Cell(int x, int y, int z)
        {
            this.x = x;
            this.y = y;
            this.cost = z;
        }
    }

    /* To verify whether a move is within the boundary. */
    static boolean isSafe(int x, int y)
    {
        return x >= 0 && x < R && y >= 0 && y < C;
    }

    /* This solution is based on Dijkstra’s shortest path
     algorithm
     * For each unit square being visited, we examine all
        possible next moves in 8 directions,
     *    calculate the accumulated cost of path for each
         next move, adjust the cost of path of the adjacent
         units to the minimum as needed.
     *    then add the valid next moves into a Min Heap.
     * The Min Heap pops out the next move with the minimum
       accumulated cost of path.
     * Once the iteration reaches the last unit at the lower
       right corner, the minimum cost path will be returned.
     */
    static int minCost(int cost[][], int m, int n)
    {

        /* the array to store the accumulated cost
           of path from top left corner */
        int[][] dp = new int[R][C];

        /* the array to record whether a unit
           square has been visited */
        boolean[][] visited = new boolean[R][C];

        /* Initialize these two arrays, set path cost
          to maximum integer value, each unit as not visited
        */
        for (int i = 0; i < R; i++) {
            for (int j = 0; j < C; j++) {
                dp[i][j] = Integer.MAX_VALUE;
                visited[i][j] = false;
            }
        }

        /* Define a reverse priority queue.
         * Priority queue is a heap based implementation.
         * The default behavior of a priority queue is
            to have the maximum element at the top.
         * The compare class is used in the definition of
         the Min Heap.
         */
        PriorityQueue<Cell> pq
            = new PriorityQueue<>((Cell lhs, Cell rhs) -> {
                  return lhs.cost - rhs.cost;
              });

        /* initialize the starting top left unit with the
          cost and add it to the queue as the first move. */
        dp[0][0] = cost[0][0];
        pq.add(new Cell(0, 0, cost[0][0]));

        while (!pq.isEmpty()) {

            /* pop a move from the queue, ignore the units
               already visited */
            Cell cell = pq.peek();
            pq.remove();
            int x = cell.x;
            int y = cell.y;
            if (visited[x][y])
                continue;

            /* mark the current unit as visited */
            visited[x][y] = true;

            /* examine all non-visited adjacent units in 8
             directions
             * calculate the accumulated cost of path for
               each next move from this unit,
             * adjust the cost of path for each next
             adjacent units to the minimum if possible.
             */
            for (int i = 0; i < 8; i++) {
                int next_x = x + dx[i];
                int next_y = y + dy[i];
                if (isSafe(next_x, next_y)
                    && !visited[next_x][next_y]) {
                    dp[next_x][next_y] = Math.min(
                        dp[next_x][next_y],
                        dp[x][y] + cost[next_x][next_y]);
                    pq.add(new Cell(next_x, next_y,
                                    dp[next_x][next_y]));
                }
            }
        }

        /* return the minimum cost path at the lower
           right corner */
        return dp[m][n];
    }

    /* Driver code */
    public static void main(String[] args)
    {
        int cost[][] = { { 1, 8, 8, 1, 5 },
                         { 4, 1, 1, 8, 1 },
                         { 4, 2, 8, 8, 1 },
                         { 1, 5, 8, 8, 1 } };
        System.out.println(minCost(cost, 3, 4));
    }
}
// This code is contributed by karandeep1234

Python3

# Minimum Cost Path using Dijkstra’s shortest path
#  algorithm with Min Heap by dinglizeng
# Python3

# Define the number of rows and the number of columns
R = 4
C = 5

# 8 possible moves
dx = [ 1, -1, 0, 0, 1, 1, -1, -1 ]
dy = [ 0, 0, 1, -1, 1, -1, 1, -1 ]

# The data structure to store the coordinates of
#  the unit square and the cost of path from the top
#  left.
class Cell():
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.cost = z

# To verify whether a move is within the boundary.
def isSafe(x, y):
    return (x >= 0 and x < R and
            y >= 0 and y < C)

# This solution is based on Dijkstra’s shortest
#  path algorithm
# For each unit square being visited, we examine all
#  possible next moves in 8 directions,
# calculate the accumulated cost of path for each
#  next move, adjust the cost of path of the adjacent
#  units to the minimum as needed.
# then add the valid next moves into a Min Heap.
# The Min Heap pops out the next move with the minimum
# accumulated cost of path.
# Once the iteration reaches the last unit at the lower
# right corner, the minimum cost path will be returned.
def minCost(cost, m, n):

    # the array to store the accumulated cost
    # of path from top left corner
    dp = [[0 for x in range(C)] for x in range(R)]

    # the array to record whether a unit
    # square has been visited
    visited = [[False for x in range(C)]
                for x in range(R)]

    # Initialize these two arrays, set path cost
    # to maximum integer value, each unit as
    # not visited
    for i in range(R):
        for j in range(C):
            dp[i][j] = float("Inf")
            visited[i][j] = False

    # Define a reverse priority queue.
    # Priority queue is a heap based implementation.
    # The default behavior of a priority queue is
    # to have the maximum element at the top.
    # The compare class is used in the definition of
    # the Min Heap.
    pq = []

    # initialize the starting top left unit with the
    # cost and add it to the queue as the first move.
    dp[0][0] = cost[0][0]
    pq.append(Cell(0, 0, cost[0][0]))

    while(len(pq)):

        # pop a move from the queue, ignore the units
        # already visited
        cell = pq[0]
        pq.pop(0)
        x = cell.x
        y = cell.y
        if(visited[x][y]):
            continue

        # mark the current unit as visited
        visited[x][y] = True

        # examine all non-visited adjacent units in 8
        # directions
        # calculate the accumulated cost of path for
        # each next move from this unit,
        # adjust the cost of path for each next
        # adjacent units to the minimum if possible.
        for i in range(8):
            next_x = x + dx[i]
            next_y = y + dy[i]
            if(isSafe(next_x, next_y) and
                not visited[next_x][next_y]):
                dp[next_x][next_y] = min(dp[next_x][next_y],
                                        dp[x][y] + cost[next_x][next_y])
                pq.append(Cell(next_x, next_y,
                                dp[next_x][next_y]))

    # return the minimum cost path at the lower
    # right corner
    return dp[m][n]

# Driver code
cost = [[1, 8, 8, 1, 5],
        [4, 1, 1, 8, 1],
        [4, 2, 8, 8, 1],
        [1, 5, 8, 8, 1]]
print(minCost(cost, 3, 4))

C#

using System;
using System.Collections.Generic;

namespace MinCostPath
{
    class Cell
    {
        public int x;
        public int y;
        public int cost;

        public Cell(int x, int y, int cost)
        {
            this.x = x;
            this.y = y;
            this.cost = cost;
        }
    }

    class Program
    {
        static int R = 4;
        static int C = 5;

        static int[] dx = { 1, -1, 0, 0, 1, 1, -1, -1 };
        static int[] dy = { 0, 0, 1, -1, 1, -1, 1, -1 };

        static bool isSafe(int x, int y)
        {
            return (x >= 0 && x < R && y >= 0 && y < C);
        }

        static int minCost(int[,] cost, int m, int n)
        {
            int[,] dp = new int[R, C];
            bool[,] visited = new bool[R, C];

            for (int i = 0; i < R; i++)
            {
                for (int j = 0; j < C; j++)
                {
                    dp[i, j] = int.MaxValue;
                    visited[i, j] = false;
                }
            }

            List<Cell> pq = new List<Cell>();

            dp[0, 0] = cost[0, 0];
            pq.Add(new Cell(0, 0, cost[0, 0]));

            while (pq.Count > 0)
            {
                Cell cell = pq[0];
                pq.RemoveAt(0);

                int x = cell.x;
                int y = cell.y;

                if (visited[x, y])
                {
                    continue;
                }

                visited[x, y] = true;

                for (int i = 0; i < 8; i++)
                {
                    int next_x = x + dx[i];
                    int next_y = y + dy[i];

                    if (isSafe(next_x, next_y) && !visited[next_x, next_y])
                    {
                        dp[next_x, next_y] = Math.Min(dp[next_x, next_y], dp[x, y] + cost[next_x, next_y]);
                        pq.Add(new Cell(next_x, next_y, dp[next_x, next_y]));
                    }
                }
            }

            return dp[m, n];
        }

        static void Main(string[] args)
        {
            int[,] cost = new int[,]
            {
                { 1, 8, 8, 1, 5 },
                { 4, 1, 1, 8, 1 },
                { 4, 2, 8, 8, 1 },
                { 1, 5, 8, 8, 1 }
            };

            Console.WriteLine(minCost(cost, 3, 4));
        }
    }
}

Javascript

const R = 4;
const C = 5;

const dx = [1, -1, 0, 0, 1, 1, -1, -1];
const dy = [0, 0, 1, -1, 1, -1, 1, -1];
/* The data structure to store the coordinates of \\
  the unit square and the cost of path from the top left. */
class Cell {
    constructor(x, y, cost) {
        this.x = x;
        this.y = y;
        this.cost = cost;
    }
}
/* Define a reverse priority queue. */
class PriorityQueue {
    constructor() {
        this.heap = [];
    }

    push(cell) {
        this.heap.push(cell);
        this.heap.sort((a, b) => a.cost - b.cost);
    }

    pop() {
        return this.heap.shift();
    }

    empty() {
        return this.heap.length === 0;
    }
}
/* To verify whether a move is within the boundary. */
function isSafe(x, y) {
    return x >= 0 && x < R && y >= 0 && y < C;
}
/* This solution is based on Dijkstra’s shortest path
 algorithm
 * For each unit square being visited, we examine all
    possible next moves in 8 directions,
 *    calculate the accumulated cost of path for each
     next move, adjust the cost of path of the adjacent
     units to the minimum as needed.
 *    then add the valid next moves into a Min Heap.
 * The Min Heap pops out the next move with the minimum
   accumulated cost of path.
 * Once the iteration reaches the last unit at the lower
   right corner, the minimum cost path will be returned.
 */
function minCost(cost, m, n) {
    const dp = Array(R).fill().map(() => Array(C).fill(Number.MAX_SAFE_INTEGER));
    const visited = Array(R).fill().map(() => Array(C).fill(false));
    const pq = new PriorityQueue();

    dp[0][0] = cost[0][0];
    pq.push(new Cell(0, 0, cost[0][0]));

    while (!pq.empty()) {
        const cell = pq.pop();
        const x = cell.x;
        const y = cell.y;

        if (visited[x][y]) {
            continue;
        }

        visited[x][y] = true;
        /* examine all non-visited adjacent units in 8
         directions
         * calculate the accumulated cost of path for
           each next move from this unit,
         * adjust the cost of path for each next adjacent
           units to the minimum if possible.
         */
        for (let i = 0; i < 8; i++) {
            const next_x = x + dx[i];
            const next_y = y + dy[i];

            if (isSafe(next_x, next_y) && !visited[next_x][next_y]) {
                dp[next_x][next_y] = Math.min(dp[next_x][next_y], dp[x][y] + cost[next_x][next_y]);
                pq.push(new Cell(next_x, next_y, dp[next_x][next_y]));
            }
        }
    }

    return dp[m][n];
}

const cost = [    [1, 8, 8, 1, 5],
    [4, 1, 1, 8, 1],
    [4, 2, 8, 8, 1],
    [1, 5, 8, 8, 1]
];
console.log(minCost(cost, 3, 4));

Output

 7

Time Complexity: O(V + E * logV), where V is (N*M) and E is also (N*M)
Auxiliary Space: O(N * M)

Asked in: Amazon

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.