問題描述

已知一個數組 a[n]，裡面存放著浮點數，可能是正數、負數或0。求它的所有連續子陣列中的最大和。

連續子陣列：指的是陣列的一個連續切片，即可以表示為 a[i:j],0≤i≤j<n。

連續子陣列的和：比如連續子陣列為 a[i:j] ，則和為 a[i] + a[i+1] + ... + a[j]。

比如 a = [31,-41,59,26,-53,58,97,-93,-23,84]，則問題的最優解為 187，對應的子陣列為 [59,26,-53,58,97]。

求解思路

1、暴力求解。枚舉出所有連續子陣列，計算每個子陣列的和，求最大值。時間複雜度為 O(n^3) 或 O(n^2)，具體見下面的前3個函式。

2、分治遞迴。每次將陣列對半分，分別求取兩部分的最優解，以及包含兩部分的銜接處的最優解。時間複雜度為 O(nlogn)。

3、動態規劃。時間複雜度為 O(n)。有3種方法來實現。每種方法的解釋見下面函式的註釋。

# -*- coding: utf-8 -*-
"""
Created on Tue Jul 31 22:01:19 2018

@author: gongyanshang1

輸入一個包含n個浮點數的陣列，要求輸出此陣列的任何連續子陣列中的最大和。
特殊地，如果陣列中都是負數，則最大和為0，連續子陣列長度為0。
"""

def find_max_sum_by_force(a):
    '''
    用暴力方法求解，最樸素的邏輯，三重迴圈，複雜度為O(n^3)。
    '''
 

    max_sum = 0
    for i in range(0, len(a)):
        for j in range(i, len(a)):
            sum = 0
            for idx in range(i, j+1):
                sum += a[idx]
            if sum > max_sum:
                max_sum = sum
    return max_sum

def find_max_sum_by_force2(a):
    '''
    暴力求解，將三重迴圈的最內層迴圈去掉，複雜度為O(n^2)。
    '''
 

    max_sum = 0
    for i in range(0, len(a)):
        sum = 0
        for j in range(i, len(a)):
            sum += a[j]
            if sum > max_sum:
                max_sum = sum
    return max_sum    

def find_max_sum_by_force3(a):
    '''
    暴力求解，提前計算一個累積求和的陣列。複雜度為O(n^2)。
    '''

    # 先求出從第一個索引出發，到每個索引結束的子陣列的和
    sum_list = [0] * (len(a) + 1) # 比a長一位是為了保證sum_list[-1]=0
    for i in range(0, len(a)):
        sum_list[i] = sum_list[i-1] + a[i]

    # 雙重迴圈
    max_sum = 0
    for i in range(0, len(a)):
        for j in range(i, len(a)):
            sum = sum_list[j] - sum_list[i-1]
            if sum > max_sum:
                max_sum = sum
    return max_sum

def find_max_sum_by_recursion(a):
    '''
    遞迴求解。分治思想。複雜度為O(nlogn)
    '''

    # 定義遞迴結束標誌
    if len(a) == 0:
        return 0
    if len(a) == 1:
        return max(a[0], 0)

    # 將陣列分為兩個陣列，則原問題的最大和=max(前半部分的最大和，後半部分的最大和，包含中間數的子陣列的最大和)
    midx = int(len(a) / 2)
    a1 = a[:midx]
    a2 = a[midx:]

    # 計算包含中間數的子陣列的最大和
    # 計算左半部分的最大和
    lmax = 0
    sum = 0
    for i in range(midx-1, -1, -1):
        sum += a[i]
        if sum > lmax:
            lmax = sum
    # 計算右半部分的最大和
    rmax = 0
    sum = 0
    for i in range(midx, len(a)):
        sum += a[i]
        if sum > rmax:
            rmax = sum
    mid_max = lmax + rmax # 含中間數的子陣列的最大和 = 左半部分的最大和 + 右半部分的最大和

    return max(find_max_sum_by_recursion(a1), find_max_sum_by_recursion(a2), mid_max)

def find_max_sum_by_dynamic(a):
    '''
    動態規劃。複雜度為O(n)。思想是已知a[0:i]的最優解，如何求取a[0:i+1]的最優解。
    動態規劃本質是將一個個子任務的結果存起來，供下一個子任務使用。空間換取時間。
    有點像數學歸納法，已經證明了前i-1步是正確的，然後根據第i-1步和第i步的關聯關係，證明第i步也是正確的。
    '''
    max_sum = 0 # 儲存當前子陣列的最優解，供下一個子陣列使用
    max_ending = 0 # 儲存當前子陣列的以最後一個元素結尾的子陣列的最大和，供下一個子陣列使用
    for i in range(0, len(a)): # 每個迴圈求解的是 a[0:i] 的最優解
        max_ending = max(0, max_ending + a[i]) # 末尾子陣列的最大和，只有可能是三個值：0、末尾元素、上一個子陣列的末尾子陣列的最大和+末尾元素
        max_sum = max(max_sum, max_ending) # 當前子陣列的最優解，只有可能是兩個值：上一個子陣列的最優解、當前末尾子陣列的最大和
    return max_sum

def find_max_sum_by_scan(a):
    '''
    掃描方法，複雜度為O(n)。
    這個方法是從網上看到的，其實程式碼與動態規劃是完全等價的。
    我把它單獨又寫了一個函式，是因為它使用了另一種思路來解釋。
    演算法思想：
    1、維護一個sum值，從第一個元素開始，依次往後累加
    2、比如已經累加了前i個元素，即 a[0]~a[i-1]。如果結果大於0則繼續；
    3、如果小於0，則問題最優解只可能是兩個值：a[i:]的最優解、a[:i-1]的最優解。a[i:]的最優解已經儲存起來，因此將sum置0，重新開始累積，來計算 a[:i-1]的最優解。
      (這與find_max_sum_by_recursion方法來比，少了一個“包含中間數的子陣列的最大和”。為什麼不必考慮這個值？因為左半部分的最大和一定是0。很容易用反證法來證明此結論。)
    '''
    max_sum = 0
    sum = 0
    for i in range(0, len(a)):
        sum += a[i]
        if sum < 0:
            sum = 0
        max_sum = max(max_sum, sum)
    return max_sum

def find_max_sum_by_scan2(a):
    '''
    遞迴方法，複雜度為O(n)。
    此方法受 find_max_sum_by_scan 方法啟發。既然可以將最優解分解為 a[i:]的最優解、a[:i-1]的最優解 兩部分，那麼為什麼不可以用遞迴呢？
    '''
    # 遞迴停止規則
    if len(a) == 0:
        return 0

    max_sum = 0
    sum = 0
    for i in range(0, len(a)):
        sum += a[i]
        if sum < 0:
            return max(max_sum, find_max_sum_by_scan2(a[i+1:])) # return max(a[i:]的最優解, a[:i-1]的最優解)
        max_sum = max(max_sum, sum)
    return max_sum  

if '__main__' == __name__:
    a = [31,-41,59,26,-53,58,97,-93,-23,84]
    print(find_max_sum_by_force(a))
    print(find_max_sum_by_force2(a))
    print(find_max_sum_by_force3(a))
    print(find_max_sum_by_recursion(a))
    print(find_max_sum_by_dynamic(a))
    print(find_max_sum_by_scan(a))
    print(find_max_sum_by_scan2(a))