LeetCode55, juego de saltos (dp o codicioso)

Descripción del Título

https://leetcode-cn.com/problems/jump-game/

solución

Pensando en usar dp para hacerlo, ¿por qué está definida nuestra matriz dp?

• ¿Qué son las variables? En cada salto, la posición alcanzada es diferente, y el número de pasos que se pueden saltar en cada posición también es diferente ¿Cómo definimos dp?
• Obviamente usamos dp para expresar el número de pasos que se pueden saltar en cada posición, por lo que solo podemos elegir la posición a alcanzar, por lo que dp [i] indica si se puede alcanzar el subíndice de 0 a i
• Pensando en la recursividad, el dp [i] actual depende de si se puede alcanzar desde la posición anterior. Necesitamos mantener una variable para representar el subíndice máximo que se puede alcanzar en ese momento. Si el subíndice actual está dentro del máximo alcanzable rango de subíndice Dentro (porque puede omitir 1 paso), es cierto, así que actualice max
• El límite es dp [0] = verdadero;
• Escribir código

class Solution {
    
    
    public boolean canJump(int[] nums) {
    
    
        boolean []dp = new boolean[nums.length];//表示从0到下标i的是否可以到达

        dp[0]=true;
        int max = 0+nums[0];//当前能抵达的最大下标
        for(int i=1;i<nums.length;i++){
    
    
            if(max>=i){
    
    
                dp[i] = true;
                if(nums[i]+i>max)
                    max = nums[i]+i;//更新能抵达的最大下标
            }
            //else dp[i] = false;//不能抵达
        }
        return dp[nums.length-1];

    }
}

Según el uso de dp, la complejidad del espacio se puede optimizar:

class Solution {
    
    
    public boolean canJump(int[] nums) {
    
    
        //boolean []dp = new boolean[nums.length];//表示从0到下标i的是否可以到达

        boolean res = true;//dp[0]等于true
        int max = 0+nums[0];//当前能抵达的最大下标
        for(int i=1;i<nums.length;i++){
    
    
            if(max>=i){
    
    
                res = true;
                if(nums[i]+i>max)
                    max = nums[i]+i;//更新能抵达的最大下标
            }else
                res = false;
        }
        return res;
    }
}

¿Qué pasa si se usa un algoritmo codicioso?

Pregunta de conversión: ¿Qué tan lejos puedo saltar si apruebo las reglas de salto en la pregunta? Si puede cruzar el último cuadrado, devuelve verdadero; de lo contrario, devuelve falso.
Entonces podemos escribir el siguiente código codicioso:

	int n = nums.length;
    int farthest = 0;
    for (int i = 0; i < n - 1; i++) {
    
    
        // 不断计算能跳到的最远距离
        farthest = max(farthest, i + nums[i]);
        // 可能碰到了 0，卡住跳不动了
        if (farthest <= i) return false;
    }
    return farthest >= n - 1;

Descubrí que es similar al código anterior, ¿podemos pensar en la siguiente diferencia entre programación codiciosa y dinámica?