Java 找出数组中最长的连续统，该连续统中的值之和等于零模3

我写了一个代码，找到数组中最长的连续统，连续统中的值之和等于零模3，例如数组

a[]={2，-3,5,7，-20,7}

我们有2-3+5+7-20=-9，所以输出是5，我的问题是复杂性，现在是

O（n^3）

一只鸟低声告诉我它可以在

O（n）

公共类mmn{
公共静态void main（字符串[]args）
{
int a[]={2，-3,5,7，-20,7}；
int r=什么（a）；
系统输出println（r）；
}
专用静态int f（int[]a，int低，int高）
{
int res=0；
对于（inti=low；i在使用动态规划计算前缀和s[]之后，您可以迭代s并存储在一个新的对s[i]数组中%3在索引i中，第一个索引是最小索引，第二个是最大索引，这样新数组的长度为3，然后迭代新数组并存储0,1,2的计数，最后再次迭代该数组，并在

（cnt[3-modularoaray[i].第一个-i，cnt[3-modularoaray[i].第二个-i）。
为了好玩：

List<List<Integer>> list = IntStream.range(0, arrayLenght).mapToObj(x -> x)
            .flatMap(i -> IntStream.range(i, arrayLenght)
                    .mapToObj(j -> Arrays.stream(array).skip(i).limit(arrayLenght - j).mapToObj(t -> t)
                            .collect(Collectors.toList())))
            .collect(Collectors.toList());

int result = list.stream().filter(l -> l.stream().collect(Collectors.summingInt(u -> u)) % 3 == 0)
            .max(Comparator.comparing(List::size))
            .map(List::size)
            .orElse(-1);

List List=IntStream.range（0，arrayLenght.mapToObj（x->x）
.flatMap（i->IntStream.range（i，arrayLenght）
.mapToObj（j->array.stream（array）.skip（i）.limit（arrayLenght-j）.mapToObj（t->t）
.collect（收集器.toList（）））
.collect（Collectors.toList（））；
int result=list.stream（）.filter（l->l.stream（）.collect（Collectors.summingit（u->u））%3==0）
.max（比较器比较（列表：：大小））
.map（列表：：大小）
.orElse（-1）；

它可能可以进一步改进，以使用更少的操作

但至少它可以用于以下输入：

[1,3,3,3,1]

下面是Python中的一个
O（n）
算法的示例，该算法在数组上进行一次遍历。其思想是
dp[i][r]
表示最长的序列，
s
，在索引
i
处结束，其中
（sum s）%3=r
。显然，我们寻找最高的
dp[i][0]
。如果前一步记录了适当的模结果的任何长度，我们只能增加特定单元的序列。因为我们在数组的每次迭代中只访问三个单元（一个常数），所以算法具有
O（n）
时间和空间复杂性。（空间可以很容易地适应
O（1）
因为每次迭代只需要前三个单元格。）

a=[2，-3,5,7，-20,7]
最佳值=0
最佳索引=-1
dp=[[0,0,0]表示范围内的i（len（a）+1）]
对于范围（1，len（a）+1）内的i：
r=a[i-1]%3
对于范围（3）内的j：
canSumToJ=dp[i-1][（3+j-r）%3]>0
dp[i][j]=max（如果r==j，则为1，否则为0
，1+dp[i-1][（3+j-r）%3]如果canSumToJ其他0）
如果dp[i][0]>其他最佳最佳索引，则最佳索引=i-1
最佳=最大值（最佳，dp[i][0]）
打印（最佳，（最佳索引-最佳+1，最佳索引））#（5，（0，4））
#dp
# => [[0, 0, 0]
#    ,[0, 0, 1]
#    ,[1, 0, 2]
#    ,[0, 3, 2]
#    ,[3, 1, 4]
#    ,[5, 4, 2]
#    ,[3, 6, 5]]
让鸟告诉你它的方法。
-3+5+7-20+7
是
-4
，而不是
-3
鸟是不可信的。尤其是海鸥在O（n*n）中飞行这很容易，但因为当扩展一个子阵时，模3的净和并不总是指向一个特定的方向。我认为这只鸟实际上是一只鹰，正如它在O（n）中观察到的那样时间？时间？你应该详细说明你的尝试有什么错，否则就不清楚你为什么会把它张贴在这里。时间？时间？你应该说明你的尝试有什么错，否则你应该说明你的尝试有什么错，否则就不清楚你为什么会将你的尝试张贴在这里，否则就不清楚你为什么会将你的尝试张贴在这里。自2009年9月14日日日日日自自自2009年9月14日日日日甲甲甲甲14月14月14日若若若若若若14日自自自自自自自14日14日14日14日14日14日14日14日14日14日14日14日14日14日14日14日14日自自自自自自自自自自自自自14日14日14日14日甲甲甲甲甲甲甲甲甲14日14日14日14日14日14日14日14日自自自自自自自自自自自自自自自14日14日14日14日14日日14日日日有人能把它翻译成Java吗？请本月14日日，本月14日日，本月14日日日，本月14日日日，本月14日日日，本月14日日日，本月14日日日，本月14日日日日日日日，本月14日日，本月14日日，本月14日，本月14日，本月14日，本月14日，本月14日，本月14日，本月14日，本月14日，本月14日日，本月14日日，本月14日，本月14日日，本月14日日日，本月14日日日日日日日日，本本本本本月14日，本月14日日日，本本月14日日日日日，本本本月14日日，本本本本月14日日，本本本本本本月14日日日日日日日日日日，本本本本本本本本月14日日日，本本本本本本本本月日日，本JavaScript，如果你喜欢的话。它非常简单-
for
只是一个for循环，其中
range
类似于
I=0；I
import java.util.*;
class Main {
public static void main (String[] args) throws Exception {
// you should use only one Scanner object
Scanner scanner = new Scanner(System.in);
int a[]={3,1,3,1,3,1};
int n=a.length;
int S[]=new int[n];
int i[]=new int[n];
int best;
int sum;

for (int j=0; j<n; j++) {
    S[j]=a[j]%3;
    i[j]=j;// initialize
    //System.out.println(S[j]);
    //System.out.println(i[j]);     
}
best=1;
for (int k=1; k<n; k++) {
    if((S[k-1]+S[k])%3==0) {//checking if we want a longer continuum
        S[k]=S[k-1]+a[k];
        i[k]=i[k-1];
    }    
    if(S[k]<S[best])//check if i should update the better
        best=k-1;
    }
    System.out.println(best);
}
}

List<List<Integer>> list = IntStream.range(0, arrayLenght).mapToObj(x -> x)
            .flatMap(i -> IntStream.range(i, arrayLenght)
                    .mapToObj(j -> Arrays.stream(array).skip(i).limit(arrayLenght - j).mapToObj(t -> t)
                            .collect(Collectors.toList())))
            .collect(Collectors.toList());

int result = list.stream().filter(l -> l.stream().collect(Collectors.summingInt(u -> u)) % 3 == 0)
            .max(Comparator.comparing(List::size))
            .map(List::size)
            .orElse(-1);