La espada se refiere a la oferta 98: el número de caminos.

Pregunta:
Un robot está ubicado en la esquina superior izquierda de una cuadrícula mxn (el punto de inicio está marcado como "Inicio" en la imagen a continuación).
El robot solo puede moverse hacia abajo o hacia la derecha un paso a la vez. El robot intenta llegar a la esquina inferior derecha de la cuadrícula (etiquetada como "Finalizar" en la imagen de abajo).
P ¿Cuántos caminos diferentes hay en total?

Ejemplo 1:
Entrada: m = 3, n = 2
Salida: 3
Explicación:
Comenzando desde la esquina superior izquierda, hay un total de 3 caminos hacia la esquina inferior derecha.

1. derecha -> abajo -> abajo
2. abajo -> abajo -> derecha
3. Abajo -> Derecha -> Abajo
   Ejemplo 2:
   Entrada: m = 7, n = 3
   Salida: 28
   Análisis:
   En primer lugar, para determinar la ecuación de transición de estado, puede usar la función f(i,j) para indicar que desde la esquina superior izquierda de la cuadrícula El número de caminos desde la posición con coordenadas (0,0) hasta la posición con coordenadas (i,j). Dado que el robot solo puede moverse hacia abajo o hacia la derecha, cuando tanto i como j son mayores que 0, el robot tiene dos formas de llegar a la posición con las coordenadas (i, j). También puede bajar un paso desde la posición con coordenadas (i, j-1), entonces f(i, j)=f(i-1, j)+f(i, j-1 ).
   Si la matriz bidimensional se considera como una tabla, la primera columna y la primera fila se inicializan en 1 y luego se calculan fila por fila a través de la ecuación de transición de estado.
   
   Para optimizar aún más la eficiencia del espacio, solo necesita crear una matriz unidimensional dp, es decir, dp[n].
   Consulte la figura y el código a continuación para obtener más detalles.
   
   Código:

import java.util.Arrays;

public class UniquePaths {
    
    
//    时间空间复杂度都是mn
    public int uniquePaths1(int m, int n) {
    
    
        int[][] dp = new int[m][n];
        return helper(m - 1, n - 1, dp);
    }
    private int helper(int i, int j, int[][] dp) {
    
    
        if (dp[i][j] == 0) {
    
    
//            由于机器人只能向下或者向右走，因此当i=0时，机器人位于最上面的一行，机器人不可能
//            从某个位置向下走一步到达i等于0的位置，j=0时同理。
            if (i == 0 || j == 0){
    
    
                dp[i][j] = 1;
            }else {
    
    
                dp[i][j] = helper(i-1,j,dp)+helper(i,j-1,dp);
            }
        }
        return dp[i][j];
    }
//    时间复杂度同样是mn
    public int uniquePaths2(int m, int n) {
    
    
        int[][] dp = new int[m][n];
        Arrays.fill(dp[0],1);
        for (int i = 0; i < m; i++) {
    
    
            dp[i][0] = 1;
        }
        for (int i = 1; i < m; i++) {
    
    
            for (int j = 1; j < n; j++) {
    
    
                dp[i][j] = dp[i][j-1]+dp[i-1][j];
            }
        }
        return dp[m-1][n-1];
    }
//    优化空间效率,空间效率优化成了O（ns）
    public int uniquePaths3(int m, int n){
    
    
        int[] dp = new int[n];
        Arrays.fill(dp,1);
        for (int i = 1; i < m; i++) {
    
    
            for (int j = 1; j < n; j++) {
    
    
                dp[j] +=dp[j-1];
            }
        }
        return dp[n-1];
    }
}