# Dynamic Programming | Set 6 (Min Cost Path)

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. Total cost of a path to reach (m, n) is 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. You may assume that all costs are positive integers.

For example, in the following figure, what is the minimum cost path to (2, 2)?

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).

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

1) Optimal Substructure
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]

2) Overlapping Subproblems
Following is simple recursive implementation of the MCP (Minimum Cost Path) problem. The implementation simply follows the recursive structure mentioned above.

## C

```/* A Naive recursive implementation of MCP(Minimum Cost Path) problem */
#include<stdio.h>
#include<limits.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 program to test above functions */
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
R = 3
C = 3
import sys

# 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 program to test above functions
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.

```

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

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 apear more than once. 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 same subproblems can be avoided by constructing a temporary array tc[][] in bottom up manner.

## C++

```/* Dynamic Programming implementation of MCP problem */
#include<stdio.h>
#include<limits.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 memoery to save space. The following line is
// used to keep te 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 program to test above functions */
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 program to test above functions */
public static void main(String args[])
{
int cost[][]= {{1, 2, 3},
{4, 8, 2},
{1, 5, 3}};
System.out.println("minimum cost to reach (2,2) = " +
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 program to test above functions
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 program
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.

```

Output:

`8`

Time Complexity of the DP implementation is O(mn) which is much better than Naive Recursive implementation.

My Personal Notes arrow_drop_up

2.4 Average Difficulty : 2.4/5.0
Based on 334 vote(s)

User Actions