Description du titre
https://leetcode-cn.com/problems/jump-game/
solution
En pensant à utiliser dp pour le faire, pourquoi notre tableau dp est-il défini?
- Que sont les variables? Chaque saut, la position atteinte est différente, et le nombre de pas qui peuvent être sautés à chaque position est également différent Comment définit-on dp?
- Évidemment, nous utilisons dp pour exprimer le nombre de pas qui peuvent être sautés à chaque position, nous ne pouvons donc choisir que la position à atteindre, donc dp [i] indique si l'indice de 0 à i peut être atteint
- En ce qui concerne la récursivité, le dp [i] actuel dépend de la possibilité de l'atteindre à partir de la position précédente. Nous devons maintenir une variable pour représenter l'indice maximum pouvant être atteint pour le moment. Si l'indice actuel est dans les limites du maximum atteignable plage d'indice Dans (car vous pouvez sauter 1 étape), c'est vrai, alors mettez à jour max
- La limite est dp [0] = vrai;
- Ecrire le code
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];
}
}
Selon l'utilisation de dp, la complexité de l'espace peut être optimisée:
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;
}
}
Et si un algorithme gourmand est utilisé?
Question de conversion: jusqu'où puis-je sauter en passant les règles de saut dans la question? S'il peut traverser le dernier carré, renvoie true, sinon renvoie false.
On peut donc écrire le code gourmand suivant:
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;
Trouvé qu'il est similaire au code ci-dessus, pouvons-nous penser à la différence suivante entre la programmation gourmande et dynamique?