最大子段和问题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;

/** 5  * 
 * @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();
    }
}