跳跃游戏 I
数组的下标表示位置的编号,数组中的元素表示我们可以从当前位置向后跳多远
可以采用贪心
的策略,我们从前向后遍历一遍,对于每次遍历,需要维护一个变量 (之前可以到达的最远的位置),max (ans, i + nums[i])
。
只要发现当前位置比我们维护的可到达的最大位置大,那么就说明当前位置是无法到达的,直接返回false
。
跳跃游戏 II
相对之前的题来说,这里要求我们使用最少的跳跃次数,从起点到终点(0
- n-1
)。(这总是可以到达的
)
- 使用深度优先搜索对所有结果进行模拟
对于每一个搜索,我们维护一个当前可到达终点的最小跳跃次数min_jump
,当前可以到达的位置index
,以及当前的跳跃次数now_jump
class Solution {
public:
int jump(vector<int>& nums) {
int len = nums.size();
int min_jump = 0x0000ffff;
dfs(nums,len,0,min_jump,0);
return min_jump;
}
//深搜超时 [5,6,4,4,6,9,4,4,7,4,4,8,2,6,8,1,5,9,6,5,2,7,9,7,9,6,9,4,1,6,8,8,4,4,2,0,3,8,5]
void dfs(vector<int>& nums, int& len, int index,int& min_jump,int now_jump)
{
//判断是否可以直接跳到最后一步
if(index >= len-1)
{
min_jump = min(min_jump,now_jump);
return ;
}
for(int i = nums[index]; i > 0; i--)
dfs(nums,len,index+i,min_jump,now_jump+1);
}
};
最后,这样直接暴力去搜索显然是超时的,他的时间复杂度也是比较高的。由于模拟的问题,我们做了很多重复的工作
- 动态规划
第二种就是可以用动态规划的思想,当我们从位置A 跳到位置B 时,位置B的最少跳跃次数就等于min (dp[B], dp[A] + 1)
。要么我自己的之前维护的次数就是最小的,要么就是从0-A跳跃的次数 + 1
dp[i]
,表示从开始位置0到位置i,所需的最小跳跃次数。
class Solution {
public:
//动态规划 超时
int jump(vector<int>& nums) {
int len = nums.size();
vector<int> dp(len,0x0000ffff);//dp[i]表示跳到当前位置最小跳跃次数
dp[0] = 0;
for(int i = 0; i < len; i++)
{
int jump = min(len-1,i+nums[i]); // 可以向后跳jump个位置
for(int j = i; j <= jump; j++)
{
dp[j] = min(dp[j],dp[i]+1);
}
}
return dp[len-1];
}
};
由于双重遍历的原因,时间复杂度为O(n^2)。最终是卡在了一个逐级递减的数据集中
- 广度优先搜索
深度搜索是因为可以出现的情况很多,出现了很多重复搜索的情况,那么广度搜索可以解决这