LC55.跳跃游戏---能否到达最后一个下标---到达尾部的最小步数---贪心算法

题目1描述

给你一个非负整数数组 nums ，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标，如果可以，返回 true ；否则，返回 false 。

示例 1：

输入：nums = [2,3,1,1,4]
输出：true
解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。

示例 2：

输入：nums = [3,2,1,0,4]
输出：false
解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。

提示：

• 1 <= nums.length <= 
• 0 <= nums[i] <=

思路

  代码

#include <iostream>
#include <vector>
#include <string>
#include <sstream>

using namespace std;

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

int main() {//[2,3,1,1,4]
	string input;
	getline(cin, input);
	input = input.substr(1, input.length() - 1);
	stringstream ss(input);
	string token;
	vector<int> nums;
	while (getline(ss, token, ',')) {
		nums.push_back(stoi(token));
	}

	Solution obj;
	bool ans = obj.canJump(nums);
	cout << boolalpha << ans;
}

复杂度分析

• 时间复杂度：O(n)，其中 n 为数组的大小。只需要访问 nums 数组一遍，共 n 个位置。

• 空间复杂度：O(1)，不需要额外的空间开销。

题目描述2

给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。

每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处:

• 0 <= j <= nums[i] 
• i + j < n

返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。

示例 1:

输入: nums = [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
     从下标为 0 跳到下标为 1 的位置，跳1步，然后跳 3步到达数组的最后一个位置。

示例 2:

输入: nums = [2,3,0,1,4]
输出: 2

提示:

• 1 <= nums.length <= 104
• 0 <= nums[i] <= 1000
• 题目保证可以到达 nums[n-1]

思路1：反向查找出发的位置

代码 

//到达最后一个元素的最小跳跃步数
class Solution{
public:
	int Jump_MinStep(vector<int>& nums) {
		int index = nums.size() - 1;
		int steps = 0;
		while (index > 0) {//起始位置在下标0，反向查找出发的位置，向左遍历到起始位置下标0
			for (int i = 0; i < index; i++) {
				if (i + nums[i] >= index) {
					index = i;
					steps++;
					break;
				}
			}
		}
		return steps;
	}
}

int main() {//[2,3,1,1,4]
	string input;
	getline(cin, input);
	input = input.substr(1, input.length() - 1);
	stringstream ss(input);
	string token;
	vector<int> nums;
	while (getline(ss, token, ',')) {
		nums.push_back(stoi(token));
	}

	Solution obj;
	int ans = obj.Jump_MinStep2(nums);
	cout << ans;
}

复杂度分析

时间复杂度：O(n 2)，其中 n 是数组长度。有两层嵌套循环，在最坏的情况下，例如数组中的所有元素都是 1，position 需要遍历数组中的每个位置，对于 position 的每个值都有一次循环。

空间复杂度：O(1)。

思路2 ：正向查找可到达的最大位置

        在具体的实现中，我们维护当前能够到达的最大下标位置，记为边界。我们从左到右遍历数组，到达边界时，更新边界并将跳跃次数增加 1。

        在遍历数组时，我们不访问最后一个元素，这是因为在访问最后一个元素之前，我们的边界一定大于等于最后一个位置，否则就无法跳到最后一个位置了。如果访问最后一个元素，在边界正好为最后一个位置的情况下，我们会增加一次「不必要的跳跃次数」，因此我们不必访问最后一个元素。

代码

//到达最后一个元素的最小跳跃步数
class Solution{
public:
	int Jump_MinStep1(vector<int>& nums) {//正向查找可到达的最大位置
		int maxPos = 0;//能到达的最大下标位置
		int n = nums.size(), end = 0, step = 0;
		for (int i = 0; i < n - 1; ++i) {
			if (maxPos >= i) {
				maxPos = max(maxPos, i + nums[i]);
				if (i == end) {//到达边界时
					end = maxPos;//更新边界
					++step;
				}
			}
		}
		return step;
	}
}

int main() {//[2,3,1,1,4]
	string input;
	getline(cin, input);
	input = input.substr(1, input.length() - 1);
	stringstream ss(input);
	string token;
	vector<int> nums;
	while (getline(ss, token, ',')) {
		nums.push_back(stoi(token));
	}

	Solution obj;
	int ans = obj.Jump_MinStep2(nums);
	cout << ans;
}

复杂度分析

• 时间复杂度：O(n)，其中 n 是数组长度。

• 空间复杂度：O(1)。

 思路3：动态规划

//到达最后一个元素的最小跳跃步数
class Solution{
public:
	int Jump_MinStep2(vector<int>& nums) {//动态规划
		vector<int> dp(nums.size(), INT_MAX);
		dp[0] = 0;
		for (int i = 0; i < nums.size(); i++) {
			for (int j = 1; j <= nums[i]; j++) {
				if (i + j < nums.size()) {
					dp[i + j] = min(dp[i + j], dp[i] + 1);
				}
			}
		}
		return dp[nums.size() - 1];
	}
}