最大子序列和问题的四种算法

转自网易博客http://blog.163.com/lichunliang1988116@126/blog/static/2659944320124115795/

       云栖社区https://yq.aliyun.com/articles/40323

问题描述：给定（可能有负数）整数序列A1，A2，A3,...,An,求这个序列中子序列和的最大值。（为方便起见，如果所有整数均为负数，则最大子序列和为0）。

1.时间复杂度为O（n^3)的算法，即枚举法，将原序列的每个子序列枚举出来并求和，最后从中找出一个最大值：

 public static int maxSubsequenceSum(int[]a)
         {
          int maxSum=0;
           for(int i=0;i<a.length;i++)//遍历从第一个数开始到最后一个数，以他们为开头的子序列
            {
              for(int j=i;j<a.length;j++)//第i个数的子序列
               {
                int thisSum=0;//当前子序列的和
                for(int k=i;k<=j;k++)
                  thisSum+=a[k];
                if (thisSum>maxSum)
                 maxSum=thisSum;
                }
             }
          return maxSum;
         }

2.时间复杂度为O（n^2)的算法：即在第一个方法的基础上撤出第三个for循环（不是很懂第一个方法为何要加第三个for循环）：

 public static int maxSubsequenceSum(int[] a)
       {
        int maxSum=0;
        for(int i=0;i<a.length;i++)
         {
          int thisSum=0;
           for(int j=i;j<a length="" j="" thissum="" a="" j="" if="" thissum="">maxSum)
                maxSum=thisSum;
             }
          }
         return maxSum;
        }

  这里可以撤掉一个for循环的原因是子序列不论在哪里都可以遍历的到呢，如果是要输出最大子序列的话那就比较尴尬了。

3.时间复杂度是O(NlogN）的算法：

   用了“分治”策略。

  在例子中，最大序列的和只可能出现在3个地方：//总有一种快排的错觉

  1.出现在输入数据的左半部分

  2.出现在输入数据的右半部份

  3.跨越输入数据的中部而位于左右两个部分

  前两种情况可以递归求解，第三种情况的最大和可以通过求出前半部分（包含前半部分的最后一个元素）的最大和以及后半部分（包含后半部分的第一个元素）的最大和，在讲两者相加得到。

 public static int maxSubsequenceSum(int [] a ,int left,int right)
     {
       if (left==right)
       {
         if (a[left]>0)
          {
            return a[left];
          }else
             {
               return 0;//保证最小值是0；
             }
            }
      }
    int center=(left+right)/2;
    int maxLeftSum=maxSubsequenceSum(a,left,center);
    int maxRightSum=maxSubsequenceSum(a,center,right);
    
//求出左右包含左边右边起始位置的最大子序列和
    int leftBorderSum=0,maxLeftBorderSum=0;
    for(int i=center;i>=left;i--)
     {
      leftBorderSum+=a[i];
      if (leftBorderSum>maxLeftBorderSum)
        {
          maxLeftBorderSum=leftBorderSum;
         }
      }
     
     int rightBorderSum=0,maxRightBorderSum=0;
     for(int i=center+1;i<right i="" rightbordersum="" a="" i="" if="" rightbordersum="">maxRightBorderSum)
           {
             maxRightBorderSum=rightBorderSum;
            }
       }
//这里max3的方法没有写
    return max3（maxLeftSum,maxRightSum,maxLeftBorderSum+maxRightBorderSum);
  }

四、时间复杂度为O（N）的方法（interestingO(∩_∩)O哈哈~）

此段摘自：《数据结构与算法分析：java语言描述》机械工业出版社 第32页

一个结论是：如果a[i]是负的，那么它不可能代表最优序列的起点，因为任何包含a[i]的作为起点的子序列都可以通过用a[i+1]作起点而得到改进。类似的，任何负的子序列不可能是最优子序列的前缀（原理相同）。如果在内循环中检测到从a[i]到a[j]的子序列是负的，那么可以推进i。关键的结论是，我们不仅能够把i推进到i+1，而且实际上还可以把它一直推进到j+1。为了看清楚这一点，令p为i+1和j之间的任一下标。开始于下标p的任意子序列都不大于在下标i开始并包含从a[i]到a[p-1]的子序列的对应的子序列，因为后面这个子序列不是负的。也就是说嘛，如果当前的子序列的和没有大于前面最大子序列的和而且还是负的，那肯定是不要了的。

package MaxSequenceSum;
import java.util.Scanner;

public class MaxSequenceSum {
  public static void main(String[] args)
  {
	  Scanner input=new Scanner(System.in);
	  int n=input.nextInt();
	  int [  ] a=new int [n];
	  System.out.println();
	  for(int i=0;i<n;i++)
		  a[i]=input.nextInt();
	  System.out.println(sequencesum(a));
  }
  public static int sequencesum(int a[  ])
  {
	  int maxSum=0;
	  int nowSum=0;
	  for(int i=0;i<a.length;i++)
	  {
		  nowSum=nowSum+a[i];
		  if(nowSum>maxSum)
			   maxSum=nowSum;
		  else if(nowSum<0)
			   nowSum=0;
	  }
	  return maxSum;
  }
}