Arrays 数组元素邻接和的最优解

有人能为下面的问题提出最佳解决方案吗。 给定一个正/负整数数组，返回最大“特殊和”。给定一个数组A，每个数组索引处的“特殊和”定义如下

S[i] = S[i] + (S[i+1] + S[i+2]) + (S[i+3] + S[i+4] + S[i+5]) + (S[i+6] + S[i+7] + S[i+8] + S[i+9]) + .....

i、 e.对于索引i处的一个元素，我们添加下一个2元素，然后添加下一个3元素，然后添加下一个4元素，直到数组中有可用的数字子集

eg；数组A[1 3 1 2 5-5]=>结果：8 说明：

S[0] = 1+(3+1)+(2+5-5)=7;
s[1] = 3+(1+2)=6;
S[3] = 1+(2+5)=8; 
S[4] = 2+(5-5)=2; 
S[5] = 5; S[6] = -5;

因为S[3]是max，这就是结果。

---

这可以用3个循环来解决，有没有最佳的解决方法？

第1部分

长度为<代码> n>代码>给定的数组<代码>代码> >考虑以下顺序：

R[i] = S[i+1] + s[i+2] + s[i+3] + ... + s[N-1] + s[N]
       R[i+1] = S[i+2] + s[i+3] + ... + s[N-1] + S[N]

                   ...
                                        R[N-1] = S[n]

这意味着R[k]=S[k]+R[k+1]

环路编号1：

from N to 0 do:
  R[k] = s[k]
  if R[k+1] exists do
    R[k] = R[k] + R[k+1]

例如，如果N=9和由下图中的x'反映：

     123456789
S[0] xxxxxxxxx   
S[1]  xxxxxxxx   
S[2]   xxxxxxx   
S[3]    xxxxxx      
S[4]     xxxxx      
S[5]      xxxx      
S[6]       xxx        
S[7]        xx        
S[8]         x 

第二部分

我们假设每行求和的元素数必须是三角形数（序列元素1+2+3…，有效元素为1,3,6,10…）

让我们以我们的例子来说明这一点：

     123456789
S[0] xxxxxx   
S[1]  xxxxxx   
S[2]   xxxxxx   
S[3]    xxxxxx      
S[4]     xxx      
S[5]      xxx      
S[6]       xxx        
S[7]        x        
S[8]         x   

请注意，在每一行（索引为

i

）的末尾可能有间隙。当N-i不是三角形时，会出现间隙

例如，在索引

i=0

：

N-i=9

，小于9的最大三角形数是

6

要获得适合数字的最小三角形数字，请使用以下公式：

第二部分 现在只需迭代每个R[i]，其中i=0…N并减去不需要的部分：

for i in 0..N
  for j in 0..closest_triangle(N-i)
    R[i] = R[i] - S[i + j + 1]
  end
end

当然，您可以存储部分减法和，因为它们将被重复。例如，如果N=21：

xxxxxxxxxxxxxxxxxxxxx      
 xxxxxxxxxxxxxxx      
  xxxxxxxxxxxxxxx      
   xxxxxxxxxxxxxxx      
    xxxxxxxxxxxxxxx      
     xxxxxxxxxxxxxxx      
      xxxxxxxxxxxxxxx           
       xxxxxxxxxx           
        xxxxxxxxxx           
         xxxxxxxxxx           
          xxxxxxxxxx           
           xxxxxxxxxx               
            xxxxxx               
             xxxxxx               
              xxxxxx               
               xxxxxx                  
                xxx                  
                 xxx                  
                  xxx                    
                   x                    
                    x  

因此，这将简化计算（存储最后一些数字的总和）

关于复杂性：

在第1部分中，我们将创建大小为N的数组，并执行N个基本运算

在第2部分中，如果使用记忆（存储最后N个元素的总和），那么我们也将有N个基本操作

---

因此，算法在记忆方面将达到O（n）复杂度

：如果您从创建从第n个元素到数组末尾的部分和数组开始，那么您需要减去的所有残差都已经计算出来了（也就是说，如果最近的三角形数使您从数组末尾移除k个元素，那么它只是从这些部分和数组末尾开始计算的第k个元素）。

xxxxxxxxxxxxxxxxxxxxx      
 xxxxxxxxxxxxxxx      
  xxxxxxxxxxxxxxx      
   xxxxxxxxxxxxxxx      
    xxxxxxxxxxxxxxx      
     xxxxxxxxxxxxxxx      
      xxxxxxxxxxxxxxx           
       xxxxxxxxxx           
        xxxxxxxxxx           
         xxxxxxxxxx           
          xxxxxxxxxx           
           xxxxxxxxxx               
            xxxxxx               
             xxxxxx               
              xxxxxx               
               xxxxxx                  
                xxx                  
                 xxx                  
                  xxx                    
                   x                    
                    x