Ruta de suma máxima en una array de arriba a la izquierda a abajo a la derecha

Dada una array mat[][] de dimensiones N * M , la tarea es encontrar el camino desde la celda superior izquierda (0, 0) hasta la celda inferior derecha (N – 1, M – 1) de la celda dada. array tal que la suma de los elementos en el camino es máxima. Los únicos movimientos permitidos desde cualquier celda (i, j) de la array son (i + 1, j) o (i, j + 1) .

Ejemplos:

Entrada: mat[][] = {{3, 7}, {9, 8}}
Salida: 20
Explicación:
La ruta con suma máxima es 3 => 9 => 8 como 20.

Entrada: mat[][] = {{1, 2}, {3, 5}}
Salida: 9
Explicación:
La ruta con suma máxima es 1 => 3 => 5 como 9

Enfoque 1 (de abajo hacia arriba): la idea es utilizar la programación dinámica para resolver este problema. La observación clave es que solo se puede acceder a la celda grid[i][j] desde grid[i – 1][j] o grid[i][j – 1] . Por lo tanto, la relación de recurrencia para este problema está dada por la ecuación:

suma(i, j) = max(suma(i – 1, j), suma(i, j – 1)) + cuadrícula[i][j]

1. Inicializa una array auxiliar sum[][] de dimensiones N * M .
2. Itere sobre los elementos de la array y actualice cada celda de la array auxiliar sum[][] utilizando la relación de recurrencia formada anteriormente.
3. Después de completar los pasos anteriores, el valor sum[N][M] contendrá la suma máxima posible para una ruta desde la esquina superior izquierda hasta la esquina inferior derecha de la array dada. Imprime esa suma.

A continuación se muestra la implementación del enfoque anterior:

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the maximum sum
// path in the grid
int MaximumPath(vector<vector<int> >& grid)
{
    // Dimensions of grid[][]
    int N = grid.size();
    int M = grid[0].size();
 
    // Stores maximum sum at each cell
    // sum[i][j] from cell sum[0][0]
    vector<vector<int> > sum;
    sum.resize(N + 1,
               vector<int>(M + 1));
 
    // Iterate to compute the maximum
    // sum path in the grid
    for (int i = 1; i <= N; i++) {
 
        for (int j = 1; j <= M; j++) {
 
            // Update the maximum path sum
            sum[i][j] = max(sum[i - 1][j],
                            sum[i][j - 1])
                        + grid[i - 1][j - 1];
        }
    }
 
    // Return the maximum sum
    return sum[N][M];
}
 
// Driver Code
int main()
{
    vector<vector<int> > grid
        = { { 1, 2 }, { 3, 5 } };
 
    cout << MaximumPath(grid);
 
    return 0;
}

// Java program for
//the above approach
import java.util.*;
class GFG{
 
// Function to find the maximum sum
// path in the grid
static int MaximumPath(int [][]grid)
{
    // Dimensions of grid[][]
    int N = grid.length;
    int M = grid[0].length;
 
    // Stores maximum sum at each cell
    // sum[i][j] from cell sum[0][0]
    int [][]sum = new int[N + 1][M + 1];
 
    // Iterate to compute the maximum
    // sum path in the grid
    for (int i = 1; i <= N; i++)
    {
        for (int j = 1; j <= M; j++)
        {
            // Update the maximum path sum
            sum[i][j] = Math.max(sum[i - 1][j],
                                 sum[i][j - 1]) +
                                 grid[i - 1][j - 1];
        }
    }
 
    // Return the maximum sum
    return sum[N][M];
}
 
// Driver Code
public static void main(String[] args)
{
  int [][]grid = {{1, 2}, {3, 5}};
  System.out.print(MaximumPath(grid));
}
}
 
// This code is contributed by shikhasingrajput

# Python3 program for the above approach
 
# Function to find the maximum sum
# path in the grid
def MaximumPath(grid):
 
    # Dimensions of grid[][]
    N = len(grid)
    M = len(grid[0])
 
    # Stores maximum sum at each cell
    # sum[i][j] from cell sum[0][0]
    sum = [[0 for i in range(M + 1)]
              for i in range(N + 1)]
 
    # Iterate to compute the maximum
    # sum path in the grid
    for i in range(1, N + 1):
        for j in range(1, M + 1):
 
            # Update the maximum path sum
            sum[i][j] = (max(sum[i - 1][j],
                             sum[i][j - 1]) +
                        grid[i - 1][j - 1])
 
    # Return the maximum sum
    return sum[N][M]
 
# Driver Code
if __name__ == '__main__':
 
    grid = [ [ 1, 2 ], [ 3, 5 ] ]
 
    print(MaximumPath(grid))
 
# This code is contributed by mohit kumar 29

// C# program for the above approach
using System;
 
class GFG{
 
// Function to find the maximum sum
// path in the grid
static int MaximumPath(int [,]grid)
{
     
    // Dimensions of grid[,]
    int N = grid.GetLength(0);
    int M = grid.GetLength(1);
 
    // Stores maximum sum at each cell
    // sum[i,j] from cell sum[0,0]
    int [,]sum = new int[N + 1, M + 1];
 
    // Iterate to compute the maximum
    // sum path in the grid
    for(int i = 1; i <= N; i++)
    {
        for(int j = 1; j <= M; j++)
        {
            // Update the maximum path sum
            sum[i, j] = Math.Max(sum[i - 1, j],
                                 sum[i, j - 1]) +
                                grid[i - 1, j - 1];
        }
    }
 
    // Return the maximum sum
    return sum[N, M];
}
 
// Driver Code
public static void Main(String[] args)
{
    int [,]grid = { { 1, 2 }, { 3, 5 } };
     
    Console.Write(MaximumPath(grid));
}
}
 
// This code is contributed by Amit Katiyar

<script>
 
// JavaScript  program for
//the above approach
 
// Function to find the maximum sum
// path in the grid
function MaximumPath(grid)
{
    // Dimensions of grid[][]
    let N = grid.length;
    let M = grid[0].length;
  
    // Stores maximum sum at each cell
    // sum[i][j] from cell sum[0][0]
    let sum =  new Array(N + 1);
    // Loop to create 2D array using 1D array
    for (var i = 0; i < sum.length; i++) {
        sum[i] = new Array(2);
    }
     
    for (var i = 0; i < sum.length; i++) {
        for (var j = 0; j < sum.length; j++) {
        sum[i][j] = 0;
    }
    }
  
    // Iterate to compute the maximum
    // sum path in the grid
    for (let i = 1; i <= N; i++)
    {
        for (let j = 1; j <= M; j++)
        {
            // Update the maximum path sum
            sum[i][j] = Math.max(sum[i - 1][j],
                                 sum[i][j - 1]) +
                                 grid[i - 1][j - 1];
        }
    }
  
    // Return the maximum sum
    return sum[N][M];
}
     
// Driver Code
 
    let grid = [[1, 2], [3, 5]];
  document.write(MaximumPath(grid));
   
  // This code is contributed by souravghosh0416.
</script>

9

Complejidad de Tiempo: O(N * M)
Espacio Auxiliar: O(N * M)

Enfoque 2 (de arriba hacia abajo): Resolveremos el problema recursivamente de manera de arriba hacia abajo. Formulamos la recurrencia en función de las dos formas de llegar a la cuadrícula de celdas [i] [j] de la siguiente manera:

1. Si nos movemos un paso hacia la derecha , desde la cuadrícula de celdas [i][j-1] o,
2. Si nos movemos un paso hacia abajo , desde la celda grid[i-1][j] .

dp[i][j] = max(dp[i][j-1], dp[i-1][j]) + cuadrícula[i][j]

Por lo tanto, debemos seleccionar el paso (entre los dos anteriores) que nos da el valor máximo. Además, debemos agregar el valor presente en la celda en la que ingresamos, es decir, grid[i][j] . Como este problema tiene la propiedad de superponer subproblemas, podemos almacenar el resultado (memoizar) de los subproblemas en una array 2D (llamémosla dp ), para evitar cálculos repetidos de los mismos subproblemas. Inicialmente, configuramos todas las celdas de la tabla dp con el valor -1, y cada vez que encontramos una respuesta a un subproblema, sobrescribimos su resultado en la celda respectiva en el dp.mesa. Por lo tanto, antes de calcular cualquier subproblema, verificamos una vez que, si ese subproblema en particular se resolvió previamente o no, si se resolvió (es decir, su celda correspondiente, la array dp no es -1), simplemente devolvemos ese valor, de lo contrario lo resolvemos y almacene el resultado en la tabla  dp .

A continuación se muestra la implementación del enfoque anterior:

#include <bits/stdc++.h>
using namespace std;
 
vector<vector<int> > dp;
 
// Function to find the maximum sum path in the grid
int MaximumPathUtil(int i, int j, vector<vector<int> >& grid)
{
    // Base condition
      if (i == 0 || j == 0)
        return 0;
 
      // If current subproblem is already computed,
      // we simply return its result from the dp table
      if (dp[i][j] != -1)
        return dp[i][j];
 
      // Computing the current subproblem and
      // store the result in the dp table for future use
      return dp[i][j] = max(MaximumPathUtil(i, j-1, grid), MaximumPathUtil(i - 1, j, grid)) +
                        grid[i-1][j-1];
}
 
int MaximumPath(vector<vector<int> >& grid)
{
    // Dimensions of grid[][]
    int n = grid.size();
    int m = grid[0].size();
 
      // dp table to memoize the subproblem results
      dp.resize(n+1, vector<int> (m+1, -1));
 
      // dp[n][m] gives the max. path sum
      // from grid[0][0] to grid[n-1][m-1]
      return MaximumPathUtil(n, m, grid);
}
 
// Driver Code
int main()
{
    vector<vector<int> > grid = {{3, 7, 9, 2, 7},
                                 {9, 8, 3, 5, 5},
                                 {1, 7, 9, 8, 6},
                                 {3, 8, 6, 4, 9},
                                 {6, 3, 9, 7, 8}};
 
    cout << MaximumPath(grid);
    return 0;
}
 
// This code is contributed by tridib_samanta

/*package whatever //do not write package name here */
 
import java.io.*;
 
class GFG {
    static int dp [][];
     
    // Function to find the maximum sum path in the grid
    static int MaximumPathUtil(int i, int j, int[][] grid)
    {
        // Base condition
        if (i == 0 || j == 0)
            return 0;
     
        // If current subproblem is already computed,
        // we simply return its result from the dp table
        if (dp[i][j] != -1)
            return dp[i][j];
     
        // Computing the current subproblem and
        // store the result in the dp table for future use
        return dp[i][j] = Math.max(MaximumPathUtil(i, j-1, grid), MaximumPathUtil(i - 1, j, grid)) +
                            grid[i-1][j-1];
    }
     
    static int MaximumPath(int[][] grid)
    {
        // Dimensions of grid[][]
        int n = grid.length;
        int m = grid[0].length;
     
        // dp table to memoize the subproblem results
        dp = new int[n+1][m+1];
        for(int i=0;i<n+1;i++){
            for(int j=0;j<m+1;j++){
                dp[i][j] = -1;
            }
        }
     
        // dp[n][m] gives the max. path sum
        // from grid[0][0] to grid[n-1][m-1]
        return MaximumPathUtil(n, m, grid);
    }
     
     
// Driver Code
public static void main(String args[])
{
    int[][] grid = {{3, 7, 9, 2, 7},
                    {9, 8, 3, 5, 5},
                    {1, 7, 9, 8, 6},
                    {3, 8, 6, 4, 9},
                    {6, 3, 9, 7, 8}};
     
    System.out.println(MaximumPath(grid));
}
 
}

dp = []
 
# Function to find the maximum sum path in the grid
def MaximumPathUtil(i, j, grid):
 
    global dp
     
    # Base condition
    if (i == 0 or j == 0):
        return 0
 
    # If current subproblem is already computed,
    # we simply return its result from the dp table
    if (dp[i][j] != -1):
        return dp[i][j]
 
    # Computing the current subproblem and
    # store the result in the dp table for future use
    dp[i][j] = max(MaximumPathUtil(i, j-1, grid), MaximumPathUtil(i - 1, j, grid)) + grid[i-1][j-1]
 
    return dp[i][j]
 
def MaximumPath(grid):
 
    global dp
  
    # Dimensions of grid[][]
    n = len(grid)
    m = len(grid[0])
 
    # dp table to memoize the subproblem results
    dp = [[-1 for i in range(m + 1)] for j in range(n + 1)]
 
    # dp[n][m] gives the max. path sum
    # from grid[0][0] to grid[n-1][m-1]
    return MaximumPathUtil(n, m, grid)
 
# Driver Code
 
grid = [[3, 7, 9, 2, 7],
            [9, 8, 3, 5, 5],
            [1, 7, 9, 8, 6],
            [3, 8, 6, 4, 9],
            [6, 3, 9, 7, 8]]
 
print(MaximumPath(grid))
 
# This code is contributed by shinjanpatra

// C# program to implement above approach
using System;
using System.Collections;
using System.Collections.Generic;
 
class GFG
{
    static int[][] dp;
     
    // Function to find the maximum sum path in the grid
    static int MaximumPathUtil(int i, int j, int[][] grid)
    {
        // Base condition
        if (i == 0 || j == 0){
            return 0;
        }
     
        // If current subproblem is already computed,
        // we simply return its result from the dp table
        if (dp[i][j] != -1)
            return dp[i][j];
     
        // Computing the current subproblem and
        // store the result in the dp table for future use
        return dp[i][j] = Math.Max(MaximumPathUtil(i, j-1, grid), MaximumPathUtil(i - 1, j, grid)) + grid[i-1][j-1];
    }
     
    static int MaximumPath(int[][] grid)
    {
        // Dimensions of grid[][]
        int n = grid.Length;
        int m = grid[0].Length;
     
        // dp table to memoize the subproblem results
        dp = new int[n+1][];
        for(int i = 0 ; i <= n ; i++){
            dp[i] = new int[m + 1];
        }
 
        for(int i = 0 ; i < n + 1 ; i++){
            for(int j = 0 ; j < m + 1 ; j++){
                dp[i][j] = -1;
            }
        }
     
        // dp[n][m] gives the max. path sum
        // from grid[0][0] to grid[n-1][m-1]
        return MaximumPathUtil(n, m, grid);
    }
 
     
    // Driver code
    public static void Main(string[] args){
 
        int[][] grid = {
            new int[]{3, 7, 9, 2, 7},
            new int[]{9, 8, 3, 5, 5},
            new int[]{1, 7, 9, 8, 6},
            new int[]{3, 8, 6, 4, 9},
            new int[]{6, 3, 9, 7, 8}
        };
     
        Console.WriteLine(MaximumPath(grid));
         
    }
}
 
// This code is contributed by subhamgoyal2014.

<script>
 
let dp = [];
 
// Function to find the maximum sum path in the grid
function MaximumPathUtil(i, j, grid)
{
    // Base condition
    if (i == 0 || j == 0)
        return 0;
 
    // If current subproblem is already computed,
    // we simply return its result from the dp table
    if (dp[i][j] != -1)
        return dp[i][j];
 
    // Computing the current subproblem and
    // store the result in the dp table for future use
    return dp[i][j] = Math.max(MaximumPathUtil(i, j-1, grid),
                      MaximumPathUtil(i - 1, j, grid)) +
                      grid[i-1][j-1];
}
 
function MaximumPath(grid)
{
    // Dimensions of grid[][]
    let n = grid.length;
    let m = grid[0].length;
 
    // dp table to memoize the subproblem results
    dp = new Array(n+1);
    for(let i = 0; i <= n; i++){
        dp[i] = new Array(m + 1).fill(-1);
    }
 
    // dp[n][m] gives the max. path sum
    // from grid[0][0] to grid[n-1][m-1]
    return MaximumPathUtil(n, m, grid);
}
 
// Driver Code
let grid = [[3, 7, 9, 2, 7],
            [9, 8, 3, 5, 5],
            [1, 7, 9, 8, 6],
            [3, 8, 6, 4, 9],
            [6, 3, 9, 7, 8]];
 
document.write(MaximumPath(grid),"</br>");
 
// This code is contributed by shinjanpatra
</script>

Producción: 

67

Complejidad de tiempo: O(n*m)
Complejidad de espacio: O(n*m)