Juego de salto Leetcode55

Dada una matriz de enteros no negativos, inicialmente se encuentra en la primera posición de la matriz.

Cada elemento de la matriz representa la longitud máxima que puede saltar en esa posición.

Determine si puede alcanzar la última posición.

Ejemplo 1:

Entrada: [2,3,1,1,4]
Salida: verdadero
Explicación: Podemos saltar 1 paso desde la posición 0 a la posición 1, y luego saltar 3 pasos desde la posición 1 a la última posición.

Ejemplo 2

Entrada: [3,2,1,0,4]
Salida: falso
Explicación: Pase lo que pase , siempre alcanzará el índice 3. Pero la longitud máxima de salto de esta posición es 0, por lo que nunca puede llegar a la última posición.

A primera vista, esta pregunta debe realizarse mediante programación dinámica. Vi que la primera idea después de esta pregunta es hacer doble recorrido para determinar si se puede alcanzar cada posición. La idea es muy simple. El código es el siguiente:

class Solution {
public:
    bool canJump(vector<int>& nums) {
        vector<int> dp(nums.size(),0);
        if(nums.size()<2)return true;
        dp[0]=1;
        for(int i=0;i<nums.size();i++){
            if(dp[i]==0)continue;
            for(int j=0;j<=nums[i];j++){
                if(i+j>=nums.size()) continue;
                dp[i+j]=1;
            }
        }
        return dp[nums.size()-1]==1;
    }
};

Pero en algunos casos, es tiempo extra, este problema no puede resolverse tan violentamente. De hecho, si podemos alcanzar la posición media no es un asunto de nuestra preocupación. Lo que debemos considerar es dónde podemos llegar más lejos, por lo tanto, usamos datos para almacenar la posición máxima alcanzable. Si esta posición está detrás de la última, entonces la última Se puede alcanzar, y si no se puede alcanzar un bit en el medio, saldrá directamente. Cada actualización máxima también es para comparar la distancia máxima que se puede alcanzar actualmente y la distancia máxima que puede alcanzar la matriz.

class Solution {
public:
    bool canJump(vector<int>& nums) {
        if(nums.size()<2)return true;
        int max=0;
        for(int i=0;i<nums.size()-1;i++){
            if(max<i)break;
            max=max>(nums[i]+i)?max:(nums[i]+i);
        } 
        return max>=nums.size()-1;
    }
};