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

如何解决我们的任务是找到一个具有最大和的子序列，以使子序列中的数组中不应该有相邻元素

显示错误的答案。有人可以告诉我我缺少哪个测试用例吗？

不相邻

给出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;
}

解决方法

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

一个简单的最佳解决方案是迭代计算两个和，两个和都对应于当前索引i的最大值，

不使用假定当前值sum0的第一个和（arr[i]），使用假定当前值sum1的第二个和（arr[i]）。

#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';
    }
}