leecode 解题总结：45. Jump Game II

#include <iostream>
#include <stdio.h>
#include <vector>

using namespace std;
/*
问题:
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.

Your goal is to reach the last index in the minimum number of jumps.

For example:
Given array A = [2,3,1,1,4]

The minimum number of jumps to reach the last index is 2. (Jump 1 step from index 0 to 1, then 3 steps to the last index.)

Note:
You can assume that you can always reach the last index.

分析：
题目的意思是给定一个数组，数组中各个元素的值代表能一次所能跳跃的最大步数，希望从初始位置，到达数组最后位置，所跳跃的次数
最少。
怎么感觉是像动态规划。设dp[i]表示抵达元素A[i]所跳跃的次数，则
dp[i]={dp[j] + 1 ,if A[j] >= i - j
      {0        ,if A[j] != i - j
所以dp[i] = min( dp[j] + 1, j < i && A[j] >= i - j )
初始时:dp[0] = 0,其余dp[i] = INT_MAX
目标:dp[A.len - 1]
这里注意：A[j]表示最多允许跳跃次数，实际上可以取值0~A[j]
输入:
5(数组元素个数)
2 3 1 1 4
输出:
2

关键:
1 报错:超时，说明动态规划正确。
用贪心算法:设定当前元素能到达最右边的坐标为curEnd,可以计算出当前第i元素所能到达的最远范围为fur = max( fur , A[i] + i),当某一元素
下标j刚好等于curEnd（即之前元素所能到达的最远距离时），触发一次跳跃，此时更新curEnd = fur即可
那么初始curEnd=0
数组元素
2 3 1 1 4
下标
0 1 2 3 4
可抵达下标：i+A[i]
2 4 4 4 8

2
注意：最后一个元素不能取到
		//最后一个元素是末尾元素，无需再计算
		for(int i = 0 ; i < size - 1 ; i++)
		{
			maxFur = max(maxFur , nums.at(i) + i);//更新结点i以及之前的结点所能到达的最远距离
			//如果到达边界，触发跳跃
			if(i == curEnd)
			{
				result++;
				curEnd = maxFur;//更新下一次所能到达的最远距离
			}
		}
*/

class Solution {
public:
	int dfs(vector<int>& nums , vector<int>& dp , int n)
	{
		//鲁棒性
		if(nums.empty() || dp.empty() || n < 0 || n >= dp.size())
		{
			return 0;
		}
		//记忆化搜索
		if(dp.at(n) != INT_MAX)
		{
			return dp.at(n);
		}
		//递归基
		if(0 == n)
		{
			dp.at(n) = 0;
			return dp.at(n);
		}
		//递归步
		int minNum = 0;
		int result = INT_MAX;
		int dfsResult;
		//从后向前遍历
		for(int i = n - 1 ; i >= 0 ; i--)
		{
			//如果从当前位置可以抵达后面位置，才处理，否则，无需处理
			if( nums.at(i) < (n - i))
			{
				continue;
			}
			dfsResult = dfs(nums , dp , i);
			dp.at(i) = dfsResult;
			result = result < (dfsResult + 1) ? result : (dfsResult + 1);
			//如果只需要一步就到达，这个肯定是最少的
			if(result == 1)
			{
				break;
			}
		}
		dp.at(n) = result;//记忆化存储
		return dp.at(n);
	}

    int jump2(vector<int>& nums) {
		//数组为空，只需要0步
        if(nums.empty())
		{
			return 0;
		}
		int size = nums.size();
		vector<int> dp(size , INT_MAX);
		dp.at(0) = 0;
		int result = dfs(nums , dp , size - 1);
		return result;
    }

    int jump(vector<int>& nums) {
		//数组为空，只需要0步
        if(nums.empty())
		{
			return 0;
		}
		int size = nums.size();
		int curEnd = 0;
		int maxFur = 0;
		int result = 0;
		//最后一个元素是末尾元素，无需再计算
		for(int i = 0 ; i < size - 1 ; i++)
		{
			maxFur = max(maxFur , nums.at(i) + i);//更新结点i以及之前的结点所能到达的最远距离
			//如果到达边界，触发跳跃
			if(i == curEnd)
			{
				result++;
				curEnd = maxFur;//更新下一次所能到达的最远距离
			}
		}
		return result;
	}
};

void process()
{
	int value;
	int num;
	vector<int> nums;
	Solution solution;
	while(cin >> num )
	{
		nums.clear();
		for(int i = 0 ; i < num ; i++)
		{
			cin >> value;
			nums.push_back(value);
		}
		int result = solution.jump(nums);
		cout << result << endl;
	}
}

int main(int argc , char* argv[])
{
	process();
	getchar();
	return 0;
}