dp 27 跳跃游戏2 牛客版本

前言

虽然说这篇文章写的dp27 但是前面的这些懒得再处理了，就当是买一送一吧。要看跳跃游戏2直接跳到最后吧！

dp 23 不相邻取数

题目描述

小红拿到了一个数组。她想取一些不相邻的数，使得取出来的数之和尽可能大。你能帮帮她吗？

输入描述

第一行输入一个正整数 n ，代表数组长度

第二行输入 n 个正整数 ai，代表整个数组。
$$1\le n\le 2\ast 10^5,1\le a_i\le 5\ast 10^3$$

输入：
4
2 6 4 1

7

选取6和1

其实就是打家劫舍

直接放代码

#include <stdio.h>


int main() {
    long long result = 0;
    int n;
    scanf("%d", &n);
    int a[n], dp[n];
    for(int i = 0; i < n; ++i) {
        scanf("%d", &a[i]);
    }
    if(n == 1) {
        printf("%d", a[0]);
        return 0;
    }
    if(n == 2) {
        printf("%d", a[0] > a[1] ? a[0] : a[1]);
        return 0;
    }
    dp[0] = a[0];
    dp[1] = a[0] > a[1] ? a[0] : a[1];
    for(int i = 2; i < n; ++i) {
        dp[i] = dp[i-2]+a[i] > dp[i-1] ? dp[i-2] + a[i] : dp[i-1];
    }
    // for(int i = 0; i < n; ++i) {
    //     printf("%d ", dp[i]);
    // }
    // printf("\n");
    printf("%d",dp[n-1]);
    return 0;
}

dp 24 打家劫舍2

打家劫舍2

#include <stdio.h>

int rob(int a[], int n) {
    int dp[n];
    dp[0] = a[0];
    dp[1] = a[0] > a[1] ? a[0] : a[1];
    for(int i = 2; i < n; ++i) {
        dp[i] = dp[i-2] + a[i] > dp[i-1] ? dp[i-2] + a[i] : dp[i-1];
    }
    return dp[n-1];
}

int main() {
    int n;
    scanf("%d", &n);
    int a[n];
    for(int i = 0; i < n; ++i) {
        scanf("%d", &a[i]);
    }
    if(n == 1) {
        printf("%d", a[0]);
        return 0;
    }
    if(n == 2) {
        printf("%d", a[1] > a[0] ? a[1] : a[0]);
    }
    int r1 = rob(a, n-1), r2 = rob(a+1, n-1);
    printf("%d", r1 > r2 ? r1 : r2);
    return 0;
}

dp 25 删除相邻数字的最大分数

题目描述

给定一个长度为 n 的仅包含正整数的数组，另外有一些操作，
$$每次操作你可以选择数组中的任意一个元素a_i，同时数组中所有等于a_i-1和a_i+1的元素会被全部移除，同时你可以得到a_i分$$
直到所有的元素都被选择或者删除。请你计算最多能得到多少分。
$$数据范围：数组长度满足1\le n\le 10^5，数组中的元素大小都满足1\le a_i\le 10^4$$

思路分析

每次移除等于一个数据 +1和-1的所有数据，这和偷了一家不能再偷相邻的一家十分类似。

这题a的范围较小，那么我们可以直接做一个桶。桶的编号就是数组元素的大小。

然后桶装的就是 原数组中所有ai的和。也就是个数乘ai。

最后用打家劫舍的思路去对这个桶进行计算，就得到了最后的结果。

代码

#include <stdio.h>

int a[10001];

int rob(int a[], int n) {
    int dp[n];
    dp[0] = a[0];
    dp[1] = a[0] > a[1] ? a[0] : a[1];
    for (int i = 2; i < n; ++i) {
        dp[i] = dp[i - 2] + a[i] > dp[i - 1] ? dp[i - 2] + a[i] : dp[i - 1];
    }
    return dp[n - 1];
}

int main() {
    int n, data;
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) {
        scanf("%d", &data);
        a[data]++;
    }
    for (int i = 0; i < 10001; ++i) {
        a[i] *= i;
    }

    printf("%d", rob(a, 10001));
    return 0;
}

dp 26 跳跃游戏1

跳跃游戏1

dp 27 跳跃游戏2 牛客版本

此题未和leetcode的跳跃游戏系列重复，在此单列出来。

题目描述

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

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

2.如果无法跳跃(即数组长度为0)，也请返回-1
$$3.数据保证返回的结果不会超过整形范围，即不会超过2^{31}-1$$
数据范围:
$$0<=nums.length<=10^5$$

$$0<=nums[i]<=1000$$

简要概括

这题描述很是有点混乱，在此进行一下说明。

给一个长度为n的非负整数的数组。最开始在0下标处。

数组中的每个值既是它可以跳跃的长度，又是它的积分。

现在求出跳跃到最后一个位置的能得到的最大积分。

如果跳不到最后一个位置 或者 数组长为0，那么返回-1。

样例

6
2 4 2 1 0 100
108

6
2 4 0 2 0 100
108

6
2 3 2 1 0 100
-1

思路

此题正向进行处理，需要多次判断能跳到哪里，再去更新可达到的值。

时间复杂度较高。

在此给出别人实现的代码

#include<iostream>
using namespace std;
int dp[100000];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    bool ans = true;
    cin >> n;
    int* num = new int[n];
    for (int i = 0; i < n; ++i) {
        cin >> num[i];
        dp[i] = 0;
    }
    dp[0] = num[0];
    for (int i = 0; i < n; ++i) {
        for (int j = i + 1; dp[i] && j <= i + num[i] && j < n; ++j) {
            dp[j] = max(dp[j], dp[i] + num[j]);
        }
    }
    if (dp[n - 1] == 0)
        cout << -1;
    else
        cout << dp[n - 1];
}

但是如果我们采取逆推的方法。就能很好地利用它给的信息。

首先考虑如何才能使得值达到最大。只有当取得了所有能取得的值的时候，最后的结果才会是最大。

那么怎么去取得所有能取得的值，从最后的一个last出发，向前遍历，遇到的第一个能到达 最后位置的元素 X 必然是我们应该取得的值。

为什么？

因为如果前面还存在可以到达最后一个位置的元素，那么 这个元素肯定也能到达 X。

此时，如果我们不取X, 那么得到的结果将会比取X小，不是最优的。

所以我们应该取X。

当我们再把X的位置变为最新的 last ，此向前推进，我们最终将抵达数组首，并且按照我们的选取标准，必然选取了所有我们可以选择的元素。

此时得到的值就是最优的。

如果我们发现最后的last并没有停留在 0位置。这说明从0无法到达我们的结尾，判定为无法到达，返回-1即可。

具体代码实现如下

#include <stdio.h>

int main() {
    int n;
    scanf("%d", &n);
    int a[n];
    for(int i = 0; i < n; ++i) {
        scanf("%d", &a[i]);
    }
    
    int max = n-1, c = a[n-1];
    for(int i = n-2; i >= 0; --i) {
        if(a[i] + i >= max) {
            max = i;
            c += a[i];
        }
    }
    if(max != 0) {
        printf("-1");
        return 0;
    }
    printf("%d", c);
    return 0;
}