一道谜题中，小核桃被赋予了一个整数数组和一组规则，让他按顺序进行操作。以下是给小核桃的指示：给定一个整数数组，请按以下方法计算得分最高的方案： 首先选择一个整数vv并删除数组中所有等于vv的元素，并将它们的总和加入积分中。 同时，删除数组中所有等于v+1v+1或v-1v−1的元素，这些元素不得分。 重复上述步骤，直到数组中没有更多的元素为止。 现在，小核桃需要计算按照这些规则可以获得的最大分数是多少？C++

以下是一个可能的解法，使用了动态规划：

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n;
    cin >> n;
    vector<int> nums(n);
    for (int i = 0; i < n; i++) {
        cin >> nums[i];
    }

    // dp[i][j]表示对于数组的第i到j个元素进行操作，可以获得的最大分数
    vector<vector<int>> dp(n, vector<int>(n, 0));

    // 先处理长度为1和2的子数组的情况
    for (int i = 0; i < n; i++) {
        dp[i][i] = nums[i];
        if (i < n - 1) {
            if (nums[i] == nums[i + 1]) {
                dp[i][i + 1] = 2 * nums[i];
            } else {
                dp[i][i + 1] = max(nums[i], nums[i + 1]);
            }
        }
    }

    // 处理长度大于2的子数组的情况
    for (int len = 3; len <= n; len++) {
        for (int i = 0; i + len - 1 < n; i++) {
            int j = i + len - 1;
            // 第一种操作，选择一个整数v并删除所有等于v的元素
            for (int k = i; k <= j; k++) {
                if (nums[k] == nums[i]) {
                    int sum = nums[i];
                    if (k > i) {
                        sum += dp[i + 1][k - 1];
                    }
                    if (k < j) {
                        sum += dp[k + 1][j];
                    }
                    dp[i][j] = max(dp[i][j], sum);
                }
            }
            // 第二种操作，删除所有等于v+1或v-1的元素
            for (int k = i; k <= j; k++) {
                if (nums[k] == nums[i] + 1 || nums[k] == nums[i] - 1) {
                    int sum = 0;
                    if (i < k - 1) {
                        sum += dp[i][k - 2];
                    }
                    if (k + 1 < j) {
                        sum += dp[k + 2][j];
                    }
                    dp[i][j] = max(dp[i][j], sum);
                }
            }
        }
    }

    cout << dp[0][n - 1] << endl;

    return 0;
}

时间复杂度为 $O(n^3)$，可能会超时。可以通过优化来减少复杂度，比如使用记忆化搜索或者更高效的 DP 实现。