跳跃游戏（动态规划）

话不多少，直接上开胃菜。

跳跃游戏1

---

给定一个非负整数数组nums，假定最开始处于下标为0的位置，数组里面的每个元素代表下一跳能够跳跃的最大长度。如果能够跳到数组最后一个位置，则输出true，否则输出false。

数据范围:

1<=num.length<=2*10^5

0<=nums[i]<=10^5

输入描述：

第一行输入一个正整数 n ，表示数组 nums 的长度

第二行输入 n 个整数表示数组的每个元素

输出描述：

输出 true 或者 false

示例1

输入：

7
2 1 3 3 0 0 100

复制输出：

true

复制说明：

首先位于nums[0]=2，然后可以跳2步，到nums[2]=3的位置，再跳到nums[3]=3的位置，再直接跳到nums[6]=100，可以跳到最后，输出true   

示例2

输入：

7
2 1 3 2 0 0 100

输出：

false

说明：

无论怎么样，都跳不到nums[6]=100的位置   

#include <stdio.h>
int max_(int a, int b) {
    return a > b ? a : b;
}
void distance(int* a, int n) {
    int i, j, dp[200001], max = a[0];
    for (i = 0; i < n; i++) {
        dp[i] = a[i];
//保证能到第i个位置，不能说明到不了终点        if (max >= i) {
            max = max_(max, dp[i] + i);
        }
    }
    if (max >= n - 1)
        printf ("true");
    else
        printf("false");
}
int main() {
    int n, a[200001], i;
    scanf("%d", &n);
    for (i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }
    distance(a,n);
}

这样，最后通过判断max是否大于最后一个位置的下标就能确定是否能到达第i个位置了。

下面，我们来看一个进阶的版本。

---

跳跃游戏2

给定一个非负整数数组nums，假定最开始处于下标为0的位置，数组里面的每个元素代表下一跳能够跳跃的最大长度，如果可以跳到数组最后一个位置，请你求出跳跃路径中所能获得的最多的积分。

1.如果能够跳到数组最后一个位置，才能计算所获得的积分，否则积分值为-1

2.如果无法跳跃(即数组长度为0)，也请返回-1

3.数据保证返回的结果不会超过整形范围，即不会超过231−1231−1

数据范围:

0<=num.length<=2*10^5

0<=num[i]<=1000

输入描述：

第一行输入一个正整数 n 表示数组 nums的长度

第二行输入 n 个整数，表示数组 nums 的所有元素的值

输出描述：

输出能获得的最多的积分

示例1

输入：

6
2 4 2 1 0 100

复制输出：

106

复制说明：

首先位于nums[0]=2，然后可以跳1步，到nums[1]=4的位置，积分=2+4=6，再跳到nums[5]=100的位置，积分=6+100=106
这样保证既能跳到数组最后一个元素，又能保证获取的积分最多    
 

示例2

输入：

6
2 4 0 2 0 100

复制输出：

108

复制说明：

跳跃路径为：2=>4=>2=>100，总共为108        

示例3

输入：

6
2 3 2 1 0 100

复制输出：

-1

复制说明：

跳不到最后一个位置，返回-1       

游戏2在游戏1的基础上让我们求出最大积分。我自己的思路首先是确保能到达终点，如果能到达，再反过来算最大积分。于是我们函数前面的部分基本保持不变，那就是

  int dp[100001],i,j,t;
    t=n-1;
    dp[0]=a[0];
   int max=a[0],jf=0;
   if(a[0]==0) return -1;
    for(i=0;i<n;i++){
        dp[i]=a[i];
        if(max>=i){
            max=max_(max,dp[i]+i);
        }
    }

如果max大于等于终点位置的下标，下一步就是去算最大积分了，这一次我们从终点开始算积分，

要求积分最大值，应该尽可能的将每一步的积分都加上，因为前面我们已经确定了必能到终点，那么终点前的任意位置也应该能到达。对于i这个位置

可以从i-1的位置开始计算，如果能从i-1的位置到达，就加上i-1的积分，否则i-2，尽可能的多走。代码实现是这样的

if(max>=n-1){
        for(j=n-1;j>=0;j--){
            while(dp[j]+j>=t)//注意t=n-1，用这个变量方便找到能到达t位置的j(下标)，并把t的值更新为j。
                jf+=dp[j];
                t=j;
                break;
            }
        }
        return jf;
    }
   else
     return -1;

全部代码如下

#include <stdio.h>
int max_(int a,int b){
    return a>b? a:b;
}
int maxjf(int *a,int n){
    int dp[100001],i,j,t;
    t=n-1;
    dp[0]=a[0];
   int max=a[0],jf=0;
   if(a[0]==0) return -1;
    for(i=0;i<n;i++){
        dp[i]=a[i];
        if(max>=i){
            max=max_(max,dp[i]+i);
        }
    }
    if(max>=n-1){
        for(j=n-1;j>=0;j--){
            while(dp[j]+j>=t){
                jf+=dp[j];
                t=j;
                break;
            }
        }
        return jf;
    }
   else
     return -1;
}
int main() {
   int n,i,a[100001];
   scanf("%d",&n);
   for(i=0;i<n;i++){
    scanf("%d",&a[i]);
   }
   int test=maxjf(a,n);
   printf("%d",test);
}

采用jf这个变量将每一步的积分加起来，这段代码的核心思想就是更新t的值来使得尽可能的加上每一步的积分。

最后，还有一个最终版本，下篇再讲吧?