Question

给定一个整数数组，找到非相邻元素的最大总和。例如，输入[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.*;
import java.util.*;
//Maximum Sum of Non-adjacent Elements
public class Test{
public static void main(String args[])
{
    int[] a={1, 0, 3, 9, 2,-1,-2,-7};
    int max=a[0];
    int max_index=0;
    for(int i=1;i<a.length;++i)
    {
        if(max<a[i])
        {
            max=a[i];
            max_index=i;
        }
    }
    int m1=a[0];
    for(int i=1;i<max_index-1;++i) //get maximum in first half from 0 to max_index-1
    {
        if(m1<a[i])
            m1=a[i];
    }
    int m2=a[max_index+2];
    for(int i=max_index+2;i<a.length;i++)//get maximum in second half max_index+2 to end in array.
    {
        if(a[i]>m2)
        m2=a[i];
    }
    int two_non_adj_max=max+Math.max(m1,m2);
    System.out.println(two_non_adj_max);
}
}

Answer 1

您在线性时间内搜索最大值M1。

您在liner time中搜索第二个不相邻的最大值。

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;

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

希望这就是你所需要的。

对于记录：A1 + A2是A [maxs [0] - 1] + A [maxs [0] + 1]，如果maxs [0]既不是0也不是大小。

Answer 2

据我了解你的问题：

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]);
    }
}

此算法具有 O （ n ²）的复杂性。

草拟更快的算法：您可以按降序对数组值及其索引进行排序。您可以搜索具有非相邻索引的最高对。该算法采用 O （ n log n ）步骤。

Answer 3

让BEST_SUM(i)为位置<= i的非相邻元素的最大总和。

When i<0,   BEST_SUM(i) = 0
Otherwise:  BEST_SUM(i) = max( BEST_SUM(i-1), BEST_SUM(i-2)+a[i] )

BEST_SUM(a.length-1)是你的答案。

注意：这是非相邻元素的最大总和，就像您要求的那样。看看你的代码看起来你可能意味着两个非相邻元素的最佳总和。这将是不同的，更容易。

Answer 4

包 abc;

公共类解决方案{

// int[] A{1,4,5,2,5,4,2}

public int nonAdjacentMaxSumRepeated(int[] inpArray) {

    int[] a = new int[inpArray.length];
    int k=0;
    for(int i=0,j=0;i<inpArray.length;i++) {
        j=i+1; 
        //System.out.println("i="+i);
        //System.out.println("j="+j);
        System.out.println(inpArray[i]+","+inpArray[j]);
        a[k]=inpArray[i]+inpArray[j];k++;
        i=j;
    }
    
    int x=0;
    for (int i : a) {
     x = Math.max(x, i);
    }
    
    return x;
}

public static void main(String[] args) {
    System.out.println(
    new Solution().nonAdjacentMaxSumRepeated(new int[] {1,3,5,2,6,4,2,7})
    );
}

}

一维数组中非相邻元素的最大总和

4 个答案: