LeetCode 之 Jump Game（贪心算法）

【问题描述】

Given an array of non-negative integers, you are initially positioned at the first index of the array.

Each element in the array represents your maximum jump length at that position.

Determine if you are able to reach the last index.

For example:
A = [2,3,1,1,4], return true.

A = [3,2,1,0,4], return false.

1.【基础知识】

1）vector<int>.size() = num_of_elem；

2）vector<int>.length() 非法；

3）((vector<int>::begin()++) - vector<int>::begin()) = 1而不是 sizeof ( int ) 。

4）数组初始化vector<int>：

	int a[]={1,2,3,4,5,6,7};
	vector<int> nums(a,a+sizeof(a)/sizeof(int));

2.【屌丝代码】

卡壳部分：

1）审题出错，忽略 maximum 的潜在含义；

2）贪心算法思想了解但不能熟练应用，贪心算法即在当前选择最优解，得到最优解的情况下进行下一步；

3）屌丝源码思想

a.如果序列长度小于等于1，那么序列直接判定为 true；

b.如果迭代器未迭代到最后 1 个元素，判断当前元素是否为 0，为 0 则判断为 false；

c.不为 0 ，则将迭代器顺移 tmp 位，判断为最后 1 位，是则返回 true ，超出则 false，未超出则继续迭代循环。

<pre name="code" class="cpp">#include <vector>  
#include <iostream>
#include <algorithm> 
#include <vector>
#include <string>

using namespace std; 

class Solution {
public:
    bool canJump(vector<int>& nums) {
		if(nums.size()<=1) return true;		
		vector<int>::iterator it = nums.begin();
		while(it-nums.begin()<nums.size())
		{
			int tmp = *it;
			if(tmp==0&&it!=nums.end()-1)
				return false;
			else
				it = it+tmp;
//			cout<<it-nums.begin()<<endl;
			if(it-nums.begin()>nums.size())
				return false;
			if(it == nums.end()-1)
				return true;
		}
    }
};

int main()  
{
	int a[]={2,5,0,0};
	vector<int> nums(a,a+sizeof(a)/sizeof(int));
	/*	
	cout<<sizeof(a)<<endl;	
	cout<<sizeof(a)/sizeof(int)<<endl;
	cout<<"*********************************************"<<endl;
	cout<<*(nums.begin())<<endl;
	// cout<<*(nums.end())<<endl; 报错		
	cout<<*(nums.begin()+1)<<endl;
	cout<<*(nums.end()-1)<<endl;
	cout<<*(nums.begin()+2)<<endl;
	cout<<*(nums.end()-2)<<endl;
	cout<<distance(nums.begin(),nums.end())<<endl;
	cout<<(nums.end()-nums.begin())<<endl;
	cout<<"*********************************************"<<endl;
	vector<int>::iterator it = nums.begin();
	it++;
	cout<<(it-nums.begin())<<endl;
	cout<<(nums.end()-it)<<endl;
	cout<<*it<<endl;
	it++;
	cout<<(it-nums.begin())<<endl;
	cout<<(nums.end()-it)<<endl;
	cout<<*it<<endl;
	*/
	Solution mySln;
	bool num = mySln.canJump(nums);
	if(num)
	cout<<"true"<<endl;
	else
	cout<<"false"<<endl;
    return 0; 
}

3.【源码AC】

分析由于每层最多可以跳 A[i] 步，也可以跳 0 或 1 步，因此如果能到达最高层，则说明每一层都可以到达。有了这个条件，说明可以用贪心法。思路一：正向，从 0 出发，一层一层网上跳，看最后能不能超过最高层，能超过，说明能到达，否则不能到达。思路二：逆向，从最高层下楼梯，一层一层下降，看最后能不能下降到第 0 层。思路三：如果不敢用贪心，可以用动规，设状态为 f[i]，表示从第 0 层出发，走到 A[i] 时剩余的最大步数，则状态转移方程为：f[i] = max(f[i − 1], A[i − 1]) − 1, i > 0代码 1// LeetCode, Jump Game// 思路 1，时间复杂度 O(n)，空间复杂度 O(1)

代码 1
// LeetCode, Jump Game
<pre name="code" class="cpp">// 思路 1，向右转移，当元素不可达（i < reach）或者超出范围（reach < nums.size()）
// 时间复杂度 O(n)，空间复杂度 O(1)
class Solution {
public:
	bool canJump(vector<int>& nums) {
		int reach = 1; // 最右能跳到哪里
		for (int i = 0; i < reach && reach < nums.size(); ++i)
			reach = max(reach, i + 1 + nums[i]);
		return reach >= nums.size();
	}
};

代码 2

// LeetCode, Jump Game
// 思路 2，时间复杂度 O(n)，空间复杂度 O(1)
// 保证 步长可达（i >= 0），超出范围（i + nums[i] >= left_most）
class Solution {
public:
	bool canJump (vector<int>& nums) {
		if (nums.size() == 0) 
			return true;
		// 逆向下楼梯，最左能下降到第几层
		int left_most = nums.size() - 1;
		for (int i = nums.size() - 2; i >= 0; --i)
			if (i + nums[i] >= left_most)
				left_most = i;
		return left_most == 0;
	}
};

代码 3

// LeetCode, Jump Game
// 思路 3，动规，时间复杂度 O(n)，空间复杂度 O(nums.size())
class Solution {
public:
	bool canJump(vector<int>& nums) {
		vector<int> f(nums.size(), 0);
		f[0] = 0;
		for (int i = 1; i < nums.size(); i++) {
			f[i] = max(f[i - 1], nums[i - 1]) - 1;
			if (f[i] < 0) 
				return false;;
		}
		return f[nums.size() - 1] >= 0;
	}
};

4.【复盘】

Consciousness ！！！

Consciousness ！！！

Consciousness ！！！