64 Suma mínima de ruta (programación recursiva y dinámica)

1. Descripción del problema:

Dada una cuadrícula de m x n que contiene enteros no negativos, encuentre una ruta desde la esquina superior izquierda a la esquina inferior derecha para que la suma de los números en la ruta sea la más pequeña.

Nota: Solo puede moverse un paso hacia abajo o hacia la derecha a la vez.

Ejemplo:

Entrada:
[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
de salida: 7
Explicación: la suma más pequeña porque la ruta 1 → 3 → 1 → 1 → 1 en.

Fuente:
enlace de LeetCode : https://leetcode-cn.com/problems/minimum-path-sum

2. Análisis de pensamiento:

① En primer lugar, podemos usar la recursión para resolver el problema de probar el camino, que se puede dividir en dos estados paralelos de caminar hacia abajo y caminar hacia la derecha. Vaya a la derecha o abajo, repita si puede, agregue una variable k en el método recursivo para registrar la ruta y la posición actual, si puede bajar, entonces el siguiente punto será El valor se agrega a la suma de la ruta, lo que significa que se puede alcanzar la suma de la siguiente ruta, pero el tiempo recursivo es relativamente grande, para la gran cantidad de datos, pero solo a través de 25 casos de prueba

También vale la pena aprender en el código recursivo proporcionado por el funcionario. Es la recursión con un valor de retorno. Al recursivo, el valor de la posición actual se agrega al valor mínimo de recursión descendente y recursiva izquierda. Vale la pena aprender la idea.

"Debido a que la recursión se agotó, todavía quiero resolver otros problemas. De hecho, este problema es relativamente simple de entender. Es fácil encontrar que el valor mínimo de la posición actual en la ruta actual en la ruta más corta y el proceso de formación están determinados por El valor mínimo del elemento superior se agrega al valor de la posición actual. La matriz de combinación es muy fácil de entender. Mientras sigamos haciendo esto en el bucle, podemos obtener el valor mínimo de la posición actual.

③ También puede usar una matriz unidimensional para resolver el problema de la hebilla del collar, pero es más difícil de entender. Si usa una matriz bidimensional, será menos difícil de entender

3. El código es el siguiente:

Código recursivo que escribí yo mismo:

import java.util.Scanner;
public class Solution {
    /*使用一个全局变量来记录最小值*/
    int min = Integer.MAX_VALUE;
    public int minPathSum(int[][] grid) {
        dfs(grid, grid[0][0], grid.length, grid[0].length, 0, 0);
        return min;
    }

    public void dfs(int[][] grid, int k, int row, int col, int r, int c) {
        if (r == row - 1 && c == col - 1){
            min = Math.min(min, k);
            return;
        }
        /*提前剪枝: 两个平行状态*/
        /*向右走*/
        if (c + 1 < col){
            dfs(grid, k + grid[r][c + 1], row, col, r, c + 1);
        }
        if (r + 1 < row){
            dfs(grid, k + grid[r + 1][c], row, col, r + 1, c);
        }
    }
}

El funcionario tiene un valor de retorno recursivo:

public class Solution {
    public int calculate(int[][] grid, int i, int j) {
        if (i == grid.length || j == grid[0].length) return Integer.MAX_VALUE;
        if (i == grid.length - 1 && j == grid[0].length - 1) return grid[i][j];
        return grid[i][j] + Math.min(calculate(grid, i + 1, j), calculate(grid, i, j + 1));
    }
    public int minPathSum(int[][] grid) {
        return calculate(grid, 0, 0);
    }
}

Mi propio código de programación dinámica:

import java.util.Scanner;
public class Solution {
    public int minPathSum(int[][] grid) {
        int r = grid.length, c = grid[0].length;
        int dp[][] = new int[r][c];
        dp[0][0] = grid[0][0];
        /*初始化第一行*/
        for (int i = 1; i < c; ++i){
            dp[0][i] = dp[0][i - 1] + grid[0][i];
        }
        /*初始化第一列*/
        for (int i = 1; i < r; ++i){
            dp[i][0] = dp[i - 1][0] + grid[i][0];
        }
        for (int i = 1; i < r; ++i){
            for (int j = 1; j < c; ++j){
                /*逻辑其实很好理解到达当前最短的路径和: 左边元素与上边元素的最小值*/
                dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
            }
        }
        return dp[r - 1][c - 1];
    }
}