# 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 ``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 ``#include ``#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

 ``

## PHP

 ``

Output
``` 8

```

Time Complexity: O((M * N)3)
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 ``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 ``#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 ``#include ``#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

 ``

## PHP

 ``

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 ``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 ` `#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

 ``

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 ``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, 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 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 pq = ``new` `List();` `            ``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)