任务是找到一个总和最大的子序列，使得子序列中的数组中不应该有相邻的元素

Question

它显示了错误的答案。谁能告诉我我缺少哪个测试用例？

不相邻

给定一个包含 N 个正整数的数组 arr[]。任务是找到一个总和最大的子序列，使得子序列中的数组中不应该有相邻的元素。

输入： 输入的第一行包含测试用例的数量 T。对于每个测试用例，输入的第一行包含数组 N 的大小。下一行包含分隔的数组空间中的 N 个元素。

输出： 对于每个测试用例，打印子序列的最大和。

约束：

1 <= T <= 100

1 <= N <= 10^6

1 <= arr[i] <= 10^6

例子：

输入：

2
3
1 2 3
3
1 20 3

输出：

4
20

解释：

测试用例 1：元素 1 和 3 形成一个总和最大的子序列，并且子序列中没有元素在数组中相邻。

测试用例 2：数组中的元素 20 形成一个总和最大的子序列。

我也尝试使用以下测试用例

输入：

3
9
1 2 9 4 5 0 4 11 6
1
0
1
1

输出：

26
0
1

它运行良好，但在提交时给出“错误答案”，我不知道它在谈论哪个测试用例

这是我的解决方案：

#include<iostream>

using namespace std;

int main()

{
    
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n;
        cin>>n;
        
        int arr[n];
        for(int i=0;i<n;i++)
            cin>>arr[i];
       
        int sum1,sum2,sum_even=0,sum_odd=0;
        
        for(int i=0;i<n;i+=2)
            sum_even+=arr[i];
        for(int i=1;i<n;i+=2)
            sum_odd+=arr[i];
        
        if(n>=1)
            sum1 = arr[0];
        else
            sum1 = -1;
        
        if(n>=2)
            sum2 = arr[1];
        else
            sum2 = -1;   
            
        int new_sum,i;
        
        for(i=2; i<n; i+=2)
        {
            if((i+1)!=n && arr[i+1]>arr[i])
            {
                i++;
                sum1+=arr[i];
            }
            else if(i+1==n)
            {
                sum1+=arr[i];
            }
            else
            {
                sum1+=arr[i];
            }
        }
        
        for(i=3; i<n; i+=2)
        {
            if((i+1)!=n && arr[i+1]>arr[i])
            {
                i++;
                sum2+=arr[i];
            }
            else if(i+1 ==n)
            {
                sum2+=arr[i];
            }
            else
            {
                sum2+=arr[i];
            }
        }
        
        int sum = sum1>sum2 ? sum1 : sum2;
        sum = sum>sum_odd ? sum : sum_odd;
        sum = sum>sum_even ? sum : sum_even;
      
        cout<<sum<<endl;
    }
    return 0;
}

Answer 1

问题是您似乎对任何解决方案的结构做出了一些猜测。
您的代码相当复杂，很难有效地手动找到反例。
我随机生成了一组数组，并将您的结果与最佳结果进行了比较。
我终于得到了这个反例：[14 18 8 19 22 1 20 23]。您的代码给出的结果为 64，而最佳总和等于 67。

一个简单的最佳解决方案是迭代计算两个和，两者都对应于当前索引i的最大值， 不使用假设当前值arr[i] 的第一个总和（sum0），使用假设当前值arr[i] 的第二个总和（sum1）。

#include <iostream>
#include <vector>
#include <algorithm>

int max_sum (const std::vector<int>& arr) {
    int sum0 = 0; 
    int sum1 = arr[0];
    int n = arr.size();
    
    for (int i = 1; i < n; ++i) {
        int temp = sum0;
        sum0 = std::max (sum0, sum1);
        sum1 = temp + arr[i];
    }
    return std::max (sum0, sum1);
}

int main() {
    int t;
    std::cin >> t;
    while(t--) {
        int n;
        std::cin >> n;
        std::vector<int> arr(n);
        for(int i = 0; i < n; i++)
           std::cin >> arr[i];
        int sum = max_sum (arr);
        std::cout << sum << '\n';
    }
}