求一數字序列的最大子段和(三種解法)

import java.util.Scanner;

public class MaxSum { 
    public static void main(String[] args) { 
        Scanner scan = new Scanner(System.in);
        System.out.println("請輸入整數個數：");
        int N = scan.nextInt();
        int[] arr = new int[N];
        System.out.println("請輸入整數序列(各數據間用空格隔開)：");
        for(int i=0;i<N;i++){
        	arr[i] = scan.nextInt();
        }                           
        System.out.println("各算法所求最大子段和分別爲："); 
        System.out.println("分治算法最優值：" + maxSumDiv(arr, 0, arr.length - 1)); 
        System.out.println("==========================="); 
        maxSumDp(arr); 
        System.out.println("==========================="); 
        maxSumSimp(arr, 0, 0); 
    } 

    // 簡單算法（需要O(n^2)計算時間）
    public static void maxSumSimp(int arr[], int bestx, int besty) { 
        int n = arr.length, sum = 0; 
        for (int i = 1; i <= n; i++) { 
            int thissum = 0;    //改變子段和的首數字時，須將當前的子段和清零
            for (int j = i; j <= n; j++) { 
                thissum += arr[j - 1]; 
                if (thissum > sum) { 
                    sum = thissum; 
                    bestx = i; 
                    besty = j; 
                } 
            } 
        } 
        System.out.println("簡單算法最優值：" + sum); 
        System.out.println("最優解：" + bestx + "-->" + besty); 
    } 
 
    // 分治算法實現（需要O(nlogn)的計算時間）  
    public static int maxSumDiv(int[] arr, int left, int right) { 
        int sum = 0; 
        if (left == right) { 
            sum = arr[left] > 0 ? arr[left] : 0; 
        } else { 
            int center = (left + right) / 2; 
            int leftSum = maxSumDiv(arr, left, center); 
            int rightSum = maxSumDiv(arr, center + 1, right); 
            int s1 = 0; 
            int lefts = 0; 
            for (int i = center; i >= left; i--) { 
                lefts += arr[i]; 
                if (lefts > s1) { 
                    s1 = lefts; 
                } 
            } 
            int s2 = 0; 
            int rights = 0; 
            for (int i = center + 1; i <= right; i++) { 
                rights += arr[i]; 
                if (rights > s2) { 
                    s2 = rights; 
                } 
            } 
            sum = s1 + s2; 
            if (sum < leftSum) { 
                sum = leftSum; 
            } 
            if (sum < rightSum) { 
                sum = rightSum; 
            } 
        } 
        return sum; 
    } 
 
    // 動態規劃算法實現(只需要O(n)計算時間和O(n)空間)  
    public static void maxSumDp(int[] arr) { 
        int sum = 0, b = 0, n = arr.length, bestx = 0, besty = 0; 
        for (int i = 1; i <= n; i++) { //b是累加和
            if (b > 0) { 
                b += arr[i - 1]; //和爲正時累加
            } else { 
                b = arr[i - 1]; //否則將當前值賦給b
                bestx = i; 
            } 
            if (b > sum) { 
                sum = b; 
                besty = i; 
            } 
        } 
        System.out.println("動態規劃算法最優值：" + sum); 
        System.out.println("最優解：" + bestx + "-->" + besty); 
    } 
}

運行結果：

作爲DP的經典案例，仔細體會DP的基本思想：保存已解決的子問題的答案，避免大量的重複計算。