最大子段和问题Java实现

最大子段和问题

一、问题描述
　　给定长度为n的整数序列，a[1...n], 求[1,n]某个子区间[i , j]使得a[i]+…+a[j]和最大。

　　例如(-2,11,-4,13,-5,2)的最大子段和为20,所求子区间为[2,4]，子序列是(11，-4,13)，最大子段和是20。

二、解决方法

1、穷举法（初级版）：SimpleAlgorithmOfMaximumIntervalSumLow.java

　　最容易理解，

　　用三重循环，可遍历所有子区间，一个表示起始位置，一个表示终点位置，一个求当前子序列的和

 package cn.com.zfc.everyday.test;

 /**  *
  * @title SimpleAlgorithmOfMaximumSegmentSumLow
  * @describe 最大子段和的简单算法的初级版
  * @author 张富昌
  * @date 2017年4月9日下午10:45:51
  */
 public class SimpleAlgorithmOfMaximumIntervalSumLow {
     // 最大子段和的首元素在原序列中的位置
     private static int startIndex;
     // 最大子段和的尾元素在原序列中的位置
     private static int endIndex;

     public static void main(String[] args) {
         // 原序列
         int[] array = { -2, 11, -4, 13, -5, -2 };
         System.out.println("原序列是：");
         // 输出原序列
         printSegment(0, array.length - 1, array);
         // 求最大子段和
         int maxSum = maxSum(array);
         System.out.println("最大字段和：" + maxSum);
         System.out.println("最大子段和的首元素在原序列中的位置：" + startIndex + "，最大子段和的尾元素在原序列中的位置：" + endIndex);
         System.out.println("最大字段和的子序列式：");
         // 输出最大子段和序列
         printSegment(startIndex, endIndex, array);
     }

     /**
      *
      * @param array：原序列
      * @return：最大子段和
      */
     private static int maxSum(int[] array) {
         // 假设最大子段和为 0
         int maxSum = 0;
         // 双重 for 循环遍历所有的子序列
         for (int i = 0; i < array.length; i++) {
             for (int j = 0; j < array.length; j++) {
                 // 一个 for 循环求当前子序列的和
                 int currentSum = 0;
                 for (int k = i; k <= j; k++) {
                     currentSum += array[k];
                 }
                 if (currentSum > maxSum) {
                     maxSum = currentSum;
                     // 最大子段和的首元素在原序列中的位置
                     startIndex = i;
                     // 最大子段和的尾元素在原序列中的位置
                     endIndex = j;
                 }
             }
         }
         return maxSum;
     }

     /**
      * 输出序列
      *
      * @param start：序列的开始下标
      * @param end：序列的结束下标
      * @param array：要输出的序列
      */
     private static void printSegment(int start, int end, int[] array) {
         for (int i = start; i <= end; i++) {
             System.out.print(array[i] + " ");
         }
         System.out.println();
     }

 }

2、穷举法（升级版）：SimpleAlgorithmOfMaximumIntervalSumHigh.java

　避免子序列的重复计算

 package cn.com.zfc.everyday.test;

 /**
  *
  * @title SimpleAlgorithmOfMaximumIntervalSumHigh
  * @describe 最大子段和的简单算法的升级版
  * @author 张富昌
  * @date 2017年4月9日下午11:17:33
  */
 public class SimpleAlgorithmOfMaximumIntervalSumHigh {
     // 最大子段和的首元素在原序列中的位置
     private static int startIndex;
     // 最大子段和的尾元素在原序列中的位置
     private static int endIndex;

     public static void main(String[] args) {
         // 原序列
         int[] array = { -2, 11, -4, 13, -5, -2 };
         System.out.println("原序列是：");
         // 输出原序列
         printSegment(0, array.length - 1, array);
         // 求最大子段和
         int maxSum = maxSum(array);
         System.out.println("最大字段和：" + maxSum);
         System.out.println("最大子段和的首元素在原序列中的位置：" + startIndex + "，最大子段和的尾元素在原序列中的位置：" + endIndex);
         System.out.println("最大字段和的子序列式：");
         // 输出最大子段和序列
         printSegment(startIndex, endIndex, array);
     }

     /**
      *
      * @param array：原序列
      * @return：最大子段和
      */
     private static int maxSum(int[] array) {
         // 假设最大子段和为 0
         int maxSum = 0;
         // 双重 for 循环遍历所有的子序列
         for (int i = 0; i < array.length; i++) {
             // 当前序列的和
             int currentSum = 0;
             // 注意 j 的初始值，避免重复计算
             for (int j = i; j < array.length; j++) {
                 currentSum += array[j];
                 if (currentSum > maxSum) {
                     maxSum = currentSum;
                     // 最大子段和的首元素在原序列中的位置
                     startIndex = i;
                     // 最大子段和的尾元素在原序列中的位置
                     endIndex = j;
                 }
             }
         }
         return maxSum;
     }

     /**
      * 输出序列
      *
      * @param start：序列的开始下标
      * @param end：序列的结束下标
      * @param array：要输出的序列
      */
     private static void printSegment(int start, int end, int[] array) {
         for (int i = start; i <= end; i++) {
             System.out.print(array[i] + " ");
         }
         System.out.println();
     }

 }

3、分治算法：BranchAlgorithmOfMaximumIntervalSum.java

 package cn.com.zfc.everyday.test;

 /**
  *
  * @title BranchAlgorithmOfMaximumIntervalSum
  * @describe 最大子段和的分治算法：
  *                 所有子区间[start, end]只可能有以下三种可能性:
  *                     在[1,n/2]这个区域内
  *                     在[n/2+1,n]这个区域内
  *                     起点位于[1,n/2],终点位于[n/2+1,n]内
  *                 以上三种情形的最大者，即为所求.
  *           前两种情形符合子问题递归特性，所以递归可以求出. 对于第三种情形，则需要单独处理.
  *           第三种情形必然包括了n/2和n/2+1两个位置，这样就可以利用第二种穷举的思路求出:
  *           以n/2为终点，往左移动扩张，求出和最大的一个startSum,以n/2+1为起点，往右移动扩张，求出和最大的一个endSum
  *           startSum + endSum是第三种情况可能的最大值
  * @author 张富昌
  * @date 2017年4月9日下午10:46:32
  */
 public class BranchAlgorithmOfMaximumIntervalSum {

     public static void main(String[] args) {
         // 原序列
         int[] array = { -2, 11, -4, 13, -5, -2 };
         System.out.println("原序列是：");
         // 输出原序列
         printSegment(0, array.length - 1, array);
         // 求最大子段和
         int maxSum = maxSum(array);
         System.out.println("最大字段和：" + maxSum);
     }

     private static int maxSum(int[] array) {
         return maxSubSum(array, 1, array.length - 1);
     }

     private static int maxSubSum(int[] array, int start, int end) {
         int sum = 0;
         if (start == end) {
             sum = array[start] > 0 ? array[end] : 0;
         } else {
             int center = (start + end) / 2;
             // 以n/2为终点，往左移动扩张，求出和最大的一个startSum
             int startSum = maxSubSum(array, start, center);
             // 以n/2+1为起点，往右移动扩张，求出和最大的一个endSum
             int endSum = maxSubSum(array, center + 1, end);
             int s1 = 0;
             int starts = 0;
             // 以n/2为终点，往左移动扩张，求出和最大的一个 startSum
             for (int i = center; i >= start; i--) {
                 starts += array[i];
                 if (starts > s1) {
                     s1 = starts;
                 }
             }
             int s2 = 0;
             int ends = 0;
             // 以n/2+1为起点，往右移动扩张，求出和最大的一个 endSum
             for (int i = center + 1; i <= end; i++) {
                 ends += array[i];
                 if (ends > s2) {
                     s1 = ends;
                 }
             }
             sum = s1 + s2;
             if (sum < startSum) {
                 sum = startSum;
             }
             if (sum < endSum) {
                 sum = endSum;
             }
         }
         return sum;
     }

     /**
      * 输出序列
      *
      * @param start：序列的开始下标
      * @param end：序列的结束下标
      * @param array：要输出的序列
      */
     private static void printSegment(int start, int end, int[] array) {
         for (int i = start; i <= end; i++) {
             System.out.print(array[i] + " ");
         }
         System.out.println();
     }

 }

4、动态规划算法

 package cn.com.zfc.everyday.test;

 /**
  *
  * @title DynamicProgrammingOfMaximumIntervalSum
  * @describe 最大子段和的动态规划算法
  * @author 张富昌
  * @date 2017年4月9日下午10:47:00
  */
 public class DynamicProgrammingOfMaximumIntervalSum {
     public static void main(String[] args) {
         // 原序列
         int[] array = { -2, 11, -4, 13, -5, -2 };
         System.out.println("原序列是：");
         // 输出原序列
         printSegment(0, array.length - 1, array);
         // 求最大子段和
         int maxSum = maxSum(array);
         System.out.println("最大字段和：" + maxSum);
     }

     /**
      *
      * @param array：原序列
      * @return：最大子段和
      */
     private static int maxSum(int[] array) {
         int sum = 0;
         int b = 0;
         for (int i = 0; i < array.length; i++) {
             if (b > 0) {
                 b += array[i];
             } else {
                 b = array[i];
             }
             if (b > sum) {
                 sum = b;
             }
         }
         return sum;
     }

     /**
      * 输出序列
      *
      * @param start：序列的开始下标
      * @param end：序列的结束下标
      * @param array：要输出的序列
      */
     private static void printSegment(int start, int end, int[] array) {
         for (int i = start; i <= end; i++) {
             System.out.print(array[i] + " ");
         }
         System.out.println();
     }
 }