LeetCode62, diferentes caminos (preguntas tipo dp)

Listo para comenzar con las preguntas de programación dinámica. Siga los pasos con honestidad para pensar en el problema. Siga los cuatro pasos principales de la autorización de ACM:

• 1. Determine el estado
  
• 2. Transferir ecuación
• 3. Condiciones iniciales y condiciones de contorno
• 4. Orden de cálculo
  

1. Descripción del título

En segundo lugar, programación dinámica para resolver problemas.

Analizar este es el problema de programación dinámica más valioso.
Uno: determinar el estado

• El último paso proviene de la columna anterior en la misma columna o de la fila anterior en la misma columna.
• Subproblema: el movimiento de (1,1) al final (m, n) se transforma en el movimiento a (m-1, n) más el movimiento de (m, n-1)
• Para determinar el estado, abrimos una ruta de matriz bidimensional [m] [n] para representar el número total de rutas desde el punto de inicio hasta el punto final.

2: Ecuación de transferencia

• si (m> = 1, n> = 1) ， ruta [m] [n] = ruta [m-1] [n] + ruta [m] [n-1];

Tres: condiciones iniciales y condiciones de contorno

• Las condiciones iniciales son path[0][0] = 0,path[0][i]=1(i>=1)，path[j][0]=1(j>=1). Porque se utiliza para participar en cálculos, aunque no se puede obtener de forma recursiva.
• La condición de límite es el valor en la instrucción if, porque m-1> = 0 y n-1> = 0 no pueden cruzar el límite. Entonces tenemos que garantizar esto.
  Cuatro: orden de cálculo
• El orden de cálculo es el proceso de cómo llenamos la tabla, donde comienza el subíndice, debemos asegurarnos de que el valor involucrado en la recursividad se calcule primero en el proceso de recursividad.

Con los pasos anteriores, comenzamos a escribir el código:

class Solution {
    
    
    public int uniquePaths(int m, int n) {
    
    
        if(m<1||n<1){
    
    
            return 0;
        }
        if(m==1||n==1)
            return 1;
        int[][] path = new int[m][n];
        path[0][0]=0;
        for(int i=0;i<n;i++){
    
    //边界初始化
            path[0][i]=1;
        }
        for(int i=0;i<m;i++){
    
    //边界初始化
            path[i][0] = 1;
        }
        for(int i=1;i<m;i++){
    
    
            for(int j = 1;j<n;j++){
    
    
                path[i][j] = path[i][j-1]+path[i-1][j];
            }
        }
        return path[m-1][n-1];

    }
}

Complejidad temporal: O (m n); Complejidad espacial: O (m n);

Tres, optimizar la complejidad del espacio

class Solution {
    
    
    public int uniquePaths(int m, int n) {
    
    
        int[] cur = new int[n];
        Arrays.fill(cur,1);
        for (int i = 1; i < m;i++){
    
    
            for (int j = 1; j < n; j++){
    
    
                cur[j] += cur[j-1] ;
            }
        }
        return cur[n-1];
    }
}

Complejidad espacial: O (N);