Problemas ruta y mínima: LeetCode-62

Problemas ruta y mínima: LeetCode-62

En primer lugar, la descripción de la temática:

Dado un número entero no negativo m * nrejilla grid, encontrar un camino de izquierda a abajo a la derecha, de modo que la suma del número mínimo de caminos.
Nota: sólo se puede dar un paso hacia abajo o hacia la derecha.
Ejemplo:

输入:
[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。

En segundo lugar, las ideas de resolución de problemas:

El problema de programación dinámica típica titulado. Tres pasos para resolver el problema

1. Definir el significado de los elementos de la matriz

Aquí podemos definir una matriz de dos dimensiones dp[][], dp[i][j]se utiliza para indicar cuando las coordenadas de punto final $(I + 1, j + 1)$ , esperamos la respuesta, que es el camino más corto a las coordenadas.

2. Encontrar la relación iterativo entre la relación elementos de la matriz

Por ejemplo, ahora tenemos que considerar cuántos conseguir este X se debe sólo a la trayectoria derecha o hacia abajo, entonces se llega Xhay dos maneras de

• Del 2 al ir al paso correcto para llegar a X
• 4 por el camino de un paso para llegar a X

nos dijimos anterior, dp[i][j]utilizado para indicar cuando las coordenadas del punto final $(I + 1, j + 1)$ , el camino más corto a nuestras necesidades. Luego de la llegadaXlongitud de la trayectoria necesaria para tener dos resultados:

• Del 2 al llegar a la derecha: 2 + X点的值7
• A partir del 4: 4+ X点的值9

Tal vez el resultado de la elección, que es obvio que elija pequeña, que es 7.

3. Definir las condiciones de contorno

El valor inicial es muy importante para determinar los pasos subsiguientes pueden obtener el resultado correcto, el valor inicial de lo que es? Es decir, porción de arco iris de colores se muestra a continuación:

4. La matriz obtenida dp

Obviamente, la esquina inferior derecha de ese elemento es una matriz bidimensional dp se les piden explicaciones

Código ordenada

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
    	/*数据不对直接跑路*/
        auto m = grid.size();
        auto n = grid[0].size();
        if(m <= 0 || n <= 0)    return 0;
        int dp[m][n];
        /*定义彩虹色部分的初始值（第1列）*/
        long sum = 0;
        for(int i = 0; i < m; i++){
            dp[i][0] = sum + grid[i][0];
            sum += grid[i][0];
        }
        /*定义彩虹色部分的初始值（第1行）*/
        sum = 0;
        for(int i = 0; i < n; i++){
            dp[0][i] = sum + grid[0][i];
            sum += grid[0][i];
        }
        /*计算*/
        for(int i = 1; i < m; i++)
            for(int j = 1; j < n; j++)
                dp[i][j] = grid[i][j] + min(dp[i - 1][j], dp[i][j - 1]);
        return dp[m - 1][n - 1];
    }
};

Los resultados operativos

no saben por qué $O (m * n)$ complejidad espacial puede promover la memoria 100%