Arrays 一维阵列中非相邻元素的最大和

给定一个整数数组，求非相邻元素的最大和。 例如，输入[1,0,3,9,2，-1]应该返回10（1+9）

应该避免3,2，因为9与3,2相邻。阵列中的最大值+非相邻元素中的最大值9（阵列中的最大元素）

因为最大元素是9，下一个最大元素应该是非相邻的。结果是9+1=10（因为1是最大值的非相邻元素中的最大值）

我在O（n）+O（Max_index-1）+O（Array.length-Max_index+2）中尝试了这种方法

是否有其他方法可以在时间复杂度方面优化此代码。

import java.io.*；
导入java.util.*；
//非相邻元素的最大和
公开课考试{
公共静态void main（字符串参数[]）
{
int[]a={1,0,3,9,2，-1，-2，-7}；
int max=a[0]；
int max_指数=0；
对于（int i=1；i，就我理解您的问题而言：

int max = Integer.MIN_VALUE;

for(int i = 0; i < a.length - 2; ++i) {
    for(int j = i + 2; j < a.length; ++j) {
        max = Math.max(max, a[i] + a[j]);
    }
}

int max=Integer.MIN\u值；
对于（int i=0；i

该算法的复杂度为O（n²）

快速算法示意图：您可以使用索引按降序对数组值进行排序。然后您可以搜索具有非相邻索引的最高对。此算法需要O（n log n）个步骤。
据我所知，您的问题：

int max = Integer.MIN_VALUE;

for(int i = 0; i < a.length - 2; ++i) {
    for(int j = i + 2; j < a.length; ++j) {
        max = Math.max(max, a[i] + a[j]);
    }
}

int max=Integer.MIN\u值；
对于（int i=0；i

该算法的复杂度为O（n²）

快速算法草图：您可以使用索引按降序对数组值进行排序。您可以搜索具有非相邻索引的最高对。此算法需要O（n logn）个步骤。
让
最佳和（i）
成为位置处非相邻元素的最大和
让
最佳和（i）
是位置处非相邻元素的最大和
在线性时间内搜索最大值M1

搜索linesr时间中第二个非相邻的最大值M2

S1=M1+M2

如果M1是第一个或最后一个元素，那么答案是S1

否则，将与M1相邻的两个值相加：

S2=A1+A2

然后该解为max（S1，S2）

好的，ShreePool对S1很感兴趣。对于其他可能感兴趣的人来说，唯一可能有更大总和的非相邻元素对正是A1和A2，好像其中一个不是，它不会与M1相邻，它会是S1的候选元素

现在，要在线性时间内找到M1和M2，有几个选项。我写了一个只需要一个过程的选项

Precondition: size >= 3;
function nonAdjacentMaxPair(a: Integer [], size: Integer): Integer [] is
   var first: Integer;
   var second: Integer;
   var third: Integer;
   var maxs: Integer [2];
   var i: Integer;
   first := 0;
   second := 1;
   third := 2;
   if (A [1] > A [0]) then
      first := 1;
      second := 0;
   endif;
   if (A [2] > A [1]) then
      third := second;
      second := 2;
      if (A [2] > A [0]) then
         second := first;
         first := 2;
      endif;
   endif;
   i := 3;
   while (i < size) do
      if (A [i] > A [third]) then
         third := i;
         if (A [i] > A [second]) then
            third := second;
            second := i;
            if(A [i] > A [first]) then
               second := first;
               first := i;
            endif;
         endif;
      endif;
      i := i + 1;
   endwhile;
   maxs [0] := first;
   maxs [1] := second;
   if (second = first + 1 or second = first - 1) then
      maxs [1] := third;
   endif;
   return maxs;
endfunction;

前提条件：大小>=3；
函数NonajacentMaxPair（a:Integer[]，大小：Integer）：Integer[]为
var-first：整数；
第二个变量：整数；
第三个变量：整数；
var maxs：整数[2]；
varⅠ：整数；
第一：=0；
第二：=1；
第三：=2；
如果（A[1]>A[0]），那么
第一：=1；
第二：=0；
endif；
如果（A[2]>A[1]），那么
第三：=第二；
第二：=2；
如果（A[2]>A[0]），那么
第二：=第一；
第一：=2；
endif；
endif；
i:=3；
而（我A[third]），那么
第三：=i；
如果（A[i]>A[second]），那么
第三：=第二；
第二：=i；
如果（A[i]>A[first]），那么
第二：=第一；
第一：=i；
endif；
endif；
endif；
i:=i+1；
结束时；
maxs[0]：=第一；
maxs[1]：=秒；
如果（第二个=第一个+1或第二个=第一个-1），则
maxs[1]：=第三；
endif；
返回最大值；
端功能；

S1是A[maxs[0]]+A[maxs[1]]

希望这是你需要的

对于记录：A1+A2是[maxs[0]-1]+A[maxs[0]+1]，如果maxs[0]既不是0也不是大小。
在线性时间内搜索最大值M1

搜索linesr时间中第二个非相邻的最大值M2

S1=M1+M2

如果M1是第一个或最后一个元素，那么答案是S1

否则，将与M1相邻的两个值相加：

S2=A1+A2

然后该解为max（S1，S2）

好的，ShreePool对S1很感兴趣。对于其他可能感兴趣的人来说，唯一可能有更大总和的非相邻元素对正是A1和A2，好像其中一个不是，它不会与M1相邻，它会是S1的候选元素

现在，要在线性时间内找到M1和M2，有几个选项。我写了一个只需要一个过程的选项

Precondition: size >= 3;
function nonAdjacentMaxPair(a: Integer [], size: Integer): Integer [] is
   var first: Integer;
   var second: Integer;
   var third: Integer;
   var maxs: Integer [2];
   var i: Integer;
   first := 0;
   second := 1;
   third := 2;
   if (A [1] > A [0]) then
      first := 1;
      second := 0;
   endif;
   if (A [2] > A [1]) then
      third := second;
      second := 2;
      if (A [2] > A [0]) then
         second := first;
         first := 2;
      endif;
   endif;
   i := 3;
   while (i < size) do
      if (A [i] > A [third]) then
         third := i;
         if (A [i] > A [second]) then
            third := second;
            second := i;
            if(A [i] > A [first]) then
               second := first;
               first := i;
            endif;
         endif;
      endif;
      i := i + 1;
   endwhile;
   maxs [0] := first;
   maxs [1] := second;
   if (second = first + 1 or second = first - 1) then
      maxs [1] := third;
   endif;
   return maxs;
endfunction;

前提条件：大小>=3；
函数NonajacentMaxPair（a:Integer[]，大小：Integer）：Integer[]为
var-first：整数；
第二个变量：整数；
第三个变量：整数；
var maxs：整数[2]；
varⅠ：整数；
第一：=0；
第二：=1；
第三：=2；
如果（A[1]>A[0]），那么
第一：=1；
第二：=0；
endif；
如果（A[2]>A[1]），那么
第三：=第二；
第二：=2；
如果（A[2]>A[0]），那么
第二：=第一；
第一：=2；
endif；
endif；
i:=3；
而（我A[third]），那么
第三：=i；
如果（A[i]>A[second]），那么
第三：=第二；
第二：=i；
如果（A[i]>A[first]），那么
第二：=第一；
第一：=i；
endif；
endif；
endif；
i:=i+1；
结束时；
maxs[0]：=第一；
maxs[1]：=秒；
如果（第二个=第一个+1或第二个=第一个-1），则
maxs[1]：=第三；
endif；
返回最大值；
端功能；

S1是A[maxs[0]]+A[maxs[1]]

希望这是你需要的

记录如下：A1+A2为[maxs[0]-1