Java 无3个连续数的数组中的最大子序列和

我必须找到数组中的最大和，这样就不会有3个连续的数字在一起 例如 3 4 5 1 2 应该还我11。（4+5+2）

我9岁就要出去了。 我使用动态规划，因为我希望运行时间为O（N） 其思想是s数组将存储最大和，s1数组将存储看到的输入长度，以跟踪连续数

import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;

public class ex {       

    public static int maxSubArraySum(int a[], int size)
    {

       int s[]= new int[size+1];
       s[0]=0;
       int s1[]= new int[size+1];
       s1[0]=0;
       for (i = 1; i <= size; i++)
       {

            s1[i]= 1+s1[i-1];
            if(s1[i]<3) {
                int k=Math.max(s[i-1], a[i-1]+s[i-1]);       
                s[i]=k;
            }
            else {
                s[i]=Math.max(a[i-1], a[i-1]+a[i]);
                s1[i]=0;
            }
       }
       return s[s.length-1];
    }



    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Scanner sc= new Scanner(System.in);
        int size=sc.nextInt();
        int a[]=new int[size];
        for(int i=0;i<size;i++) {
            a[i]=sc.nextInt();

        }
        System.out.println(maxSubArraySum(a, a.length));            

    }

}

导入java.util.array；
导入java.util.Collections；
导入java.util.Scanner；
公共类{
公共静态整数最大子数组和（整数a[]，整数大小）
{
整数s[]=新整数[size+1]；
s[0]=0；
int s1[]=新int[size+1]；
s1[0]=0；
对于（i=1；i我认为您的代码需要稍微调整，下面是您需要进行的更改

import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;

public class ex 
{       
    public static int maxSubArraySum(int a[], int size)
    {
       int s[] = new int[size+2];

       //they will form your base cases
       s[0] = 0;
       s[1] = a[0];
       s[2] = a[0] + a[1];

       for(int i = 2; i < size; i++)
       {
           s[i+1] = Math.max(a[i] + s[i-1], a[i] + a[i-1] + s[i-2]);
           s[i+1] = Math.max(s[i+1], s[i]); 
       }
       return s[size];
    }

    public static void main(String[] args) 
    {
        Scanner sc= new Scanner(System.in);
        int size=sc.nextInt();
        int a[]=new int[size];
        for(int i=0;i<size;i++) 
        {
            a[i]=sc.nextInt();
        }
        System.out.println(maxSubArraySum(a, a.length)); 
     }           
 }

导入java.util.array；
导入java.util.Collections；
导入java.util.Scanner；
公共类
{       
公共静态整数最大子数组和（整数a[]，整数大小）
{
整数s[]=新整数[size+2]；
//它们将构成您的基本案例
s[0]=0；
s[1]=a[0]；
s[2]=a[0]+a[1]；
对于（int i=2；i对于（int i=0；i考虑数组从索引0…n-1开始，即a[0…n-1]

我们创建
数组表[n+1]
，
表[i]
表示从1到i的最大和，没有三个连续的数字。在计算
表[i]
时，我们必须选择是否选择i第th个元素

因此，有三个案例

案例1：因为，我们不能选择三个连续的数字，但可以选择两个连续的数字并跳过第三个

案例2：选择ith元素并跳过（i-1）th元素

案例3：如果我们没有选择ith元素

以上，基于上述讨论，给出C++代码：
int max_sum_no_three_consecutive(int a[], int n)
{
    int table[n+1];
    table[0] = 0;
    table[1] = a[0];
    table[2] = a[1];    
    for (int i = 3; i <= n; i++) table[i] = max_3(table[i-1], table[i-2] + a[i-1], a[i-1] + a[i-2] + table[i-3]); 
        return table[n];
}

int max_sum_no_三个连续（int a[]，int n）
{
int表[n+1]；
表[0]=0；
表[1]=a[0]；
表[2]=a[1]；
对于（inti=3；i这是一篇老文章，但考虑过回答这个问题

for(int i = 0; i < input.length; i++) {
    if(0 == i) {
        sum[i] = input[0];
    } else if(1 == i) {
        sum[i] = input[0] + input[1];
    } else if(2 == i){
        sum[i] = getMaxOf3(sum[i - 1], sum[i-2] + input[i], input[i] + input[i - 1]);
    } else {
        sum[i] = getMaxOf3(sum[i - 1], sum[i - 2] + input[i], sum[i - 3] + input[i] + input[i - 1]);
    }
}

int getMaxOf3(int x, 
                 int y, 
                        int z) {
    return Math.max(Math.max(x, y), z);
}

问题是什么？给定的是一个不同的正数序列。我们希望找到一个具有最大可能和的子序列，限制是不允许从原始序列中提取三个连续元素。例如，对于输入1、6、5、2、7、9、3、4，具有最大可能和的子序列是6、5、7、9、4（我们有两对连续的元素6、5和7、9，但不是三个连续的元素）。这仍然不是问题。这只是给你的任务。你对哪部分有问题？在3 4 5 1 2的eg中。我的代码取3 4 2，给我9。它应该给4 5 2=11。我想当我在数组中的第三个元素时，我没有正确地找出最大值
Consider the array: {3, 4, 5, 1, 2}
we need to first have some default values for the result array.
sum[0] = array[0];
sum[1] = array[0] + array[1];
sum[2] = maximum of either (arr[0] + arr[1]) or (arr[1] + ar[2]) or (arr[0] + arr[2])

We calculated 3 sums,as we will be using these for furthur sum calculations.
    sum[3] = max(sum[2], sum[1] + arr[3], sum[0] + arr[3] + arr[2]);
This reduces to,
sum[i] = max(sum[i - 1], sum[i - 2] + arr[i], sum[i - 3] + arr[i] + arr[i - 1]);