Min Cost Path | DP-6 - GeeksforGeeks

21 Oct, 2021
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. 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).  
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
 
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 a simple recursive implementation of the MCP (Minimum Cost Path) problem. The implementation simply follows the recursive structure mentioned above.  
C++
C
Java
Python3
C#
PHP
Javascript
// 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 integersint min(int x, int y, int z){    if (x < y)        return (x < z) ? x : z;    else        return (y < z) ? y : z;} // Driver codeint 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
/* 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;}
/* A Naive recursive implementation ofMCP(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
# A Naive recursive implementation of MCP(Minimum Cost Path) problemR = 3C = 3import 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 functionscost= [ [1, 2, 3],        [4, 8, 2],        [1, 5, 3] ]print(minCost(cost, 2, 2)) # This code is contributed by# Smitha Dinesh Semwal
/* A Naive recursive implementation ofMCP(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/* A Naive recursive implementationof 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 thatreturns 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.?>
<script> // A Naive recursive implementation of// MCP(Minimum Cost Path) problem // A utility function that returns// minimum of 3 integersfunction 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 codevar cost = [ [ 1, 2, 3 ],             [ 4, 8, 2 ],             [ 1, 5, 3 ] ]; document.write(minCost(cost, 2, 2)); // This code is contributed by gauravrajput1 </script>
 8
Time Complexity: O(m * n)
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.
C++
C
Java
Python
C#
PHP
Javascript
/* Dynamic Programming implementation of MCP problem */#include <bits/stdc++.h>#include<limits.h>#define R 3#define C 3using 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
/* 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 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 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 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(minCost(cost,2,2));    }}// This code is contributed by Pankaj Kumar
# Dynamic Programming Python implementation of Min Cost Path# problemR = 3C = 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 functionscost = [[1, 2, 3],        [4, 8, 2],        [1, 5, 3]]print(minCost(cost, 2, 2)) # This code is contributed by Bhavya Jain
// C# program for Dynamic Programming implementation// of Min Cost Path problemusing 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.
<?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?>
<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>
 8
Time Complexity of the DP implementation is O(mn) which is much better than Naive Recursive implementation.
Auxiliary Space: O(m * n)
Space Optimization: The idea is to use the same given array to store the solutions of subproblems. 
C++
Java
Python3
C#
Javascript
#include <bits/stdc++.h>#define endl "\n"using namespace std; const int row = 3;const int 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];}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;} // Contributed by Mansimar-Anand TU_2022 p_e_k_k_a Task @ Codechef/Codeforces
// Java program for the// above approachimport 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 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 codeif __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# program for the// above approachusing 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
<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>
8
Time Complexity: O(row * col)
Auxiliary Space: O(1)
Alternate Solution We can also use the Dijkstra’s shortest path algorithm. Below is the implementation of the approach: 
C++
/* Minimum Cost Path using Dijkstra’s shortest path   algorithm with Min Heap by dinglizeng */#include <stdio.h>#include <queue>#include <limits.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 program to test above functions */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;}
 7
Using a reverse priority queue in this solution can reduce the time complexity compared with a full scan looking for the node with minimum path cost. The overall Time Complexity of the DP implementation is O(mn) without consideration of priority queue in use, which is much better than Naive Recursive implementation. 
?list=PLqM7alHXFySEQDk2MDfbwEdjd2svVJH9p  
 
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 
Sam007
Mithun Kumar
Vishal_Khoda
maveriek
dinglizeng
amit143katiyar
Rajput-Ji
nikhilchhipa9
shivanisinghss2110
GauravRajput1
decode2207
29AjayKumar
subhammahato348
subham348
Amazon
MakeMyTrip
Samsung
Dynamic Programming
Mathematical
Matrix
Amazon
Samsung
MakeMyTrip
Dynamic Programming
Mathematical
Matrix
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Largest Sum Contiguous Subarray
Bellman–Ford Algorithm | DP-23
Floyd Warshall Algorithm | DP-16
Subset Sum Problem | DP-25
Longest Palindromic Substring | Set 1
C++ Data Types
Set in C++ Standard Template Library (STL)
Merge two sorted arrays
Modulo Operator (%) in C/C++ with Examples