Dada una array de costo costo[][] y una posición (m, n) en costo[][], escriba una función que devuelva el costo del camino de costo mínimo para alcanzar (m, n) desde (0, 0). Cada celda de la array representa un costo para atravesar esa celda. El costo total de un camino para llegar a (m, n) es la suma de todos los costos en ese camino (incluidos el origen y el destino). Solo puede atravesar celdas hacia abajo, hacia la derecha y en diagonal desde una celda determinada, es decir, desde una celda determinada (i, j), celdas (i+1, j), (i, j+1) y (i+1 , j+1) se puede atravesar. Puede suponer que todos los costos son números enteros positivos.
Por ejemplo, en la siguiente figura, ¿cuál es la ruta de costo mínimo a (2, 2)?
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<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.
?>
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>
C++
/* Dynamic Programming implementation of MCP problem */
#include <bits/stdc++.h>
#include<limits.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<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
/* 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
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.
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
?>
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>
C++
#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];
}
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
#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];
}
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>
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;
}
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA