最大連續和問題

最大連續和問題。給出一個長度為n的序列 A1,A2,…,An，求最大連續和。換句話說，要求找到1≤i≤j≤n，使得Ai+Ai+1+...+Aj儘量大。

時間複雜度為n3的演算法

LL maxConSumN3(LL *a, LL n) {
    tot = 0;
    conSum = -INF;
    for(LL i = 0; i < n; i++) {
        for(LL j = i; j < n; j++) {
            LL sum = 0;
            for(LL k = i; k <= j; k++) {
                sum
 
 += a[k];
                tot++;
            }
            if(sum > conSum) {
                conSum = sum;
            }
        }
    }
    return conSum;
}

時間複雜度為n2的演算法

LL maxConSumN2(LL *a, LL n) {
    tot = 0;
    conSum = -INF;
    for(LL i = 0; i < n; i++) {
        LL sum = 0;
        for
 
(LL j = i; j < n; j++) {
            sum += a[j];
            tot++;
            if(sum > conSum) {
                conSum = sum;
            }
        }
    }
    return conSum;
}

時間複雜度為nlog2n的演算法

// 採用分治法
// 對半劃分
// 遞迴求解左半邊和右半邊的最大連續和
// 遞迴邊界為left=right
// 求解左右連線部分的最大連續和
// 合併子問題：取三者最大值
LL division(LL *a, LL lef, LL righ) {
    // 遞迴邊界
 

    if(lef == righ) {
        return a[lef];
    }
    LL center = lef + (righ - lef) / 2;
    // 左半邊最大連續和

    LL maxLeftSum = division(a, lef, center);
    // 右半邊最大連續和
    LL maxRightSum = division(a, center + 1, righ);
    // 左連線部分最大和
    LL maxLeftConSum = -INF;
    LL leftConSum = 0;
    for(LL i = center; i >= lef; i--) {
        leftConSum += a[i];
        tot++;
        if(leftConSum > maxLeftConSum) {
            maxLeftConSum = leftConSum;
        }
    }
    // 右連線部分最大和
    LL maxRightConSum = -INF;
    LL rightConSum = 0;
    for(LL i = center + 1; i <= righ; i++) {
        rightConSum += a[i];
        tot++;
        if(rightConSum > maxRightConSum) {
            maxRightConSum = rightConSum;
        }
    }
    return max(max(maxLeftSum, maxRightSum), maxLeftConSum + maxRightConSum);
}

LL maxConSumNLogN(LL *a, LL n) {
    return division(a, 0, n - 1);
}

時間複雜度為n的演算法

LL maxConSumN(LL *a, LL n) {
    conSum = -INF;
    LL sum = 0;
    tot = 0;
    for(int i = 0; i < n; i++) {
        sum += a[i];
        tot++;
        if(sum < 0) {
            sum = 0;
        }
        if(sum > conSum) {
            conSum = sum;
        }
    }
    return conSum;
}

測試主程式

#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;
const LL INF = 100000000;

// 總執行次數
LL tot;
// 最大連續和
LL conSum;

// 求最大連續和問題
// n^3的演算法
LL maxConSumN3(LL *a, LL n) {
    tot = 0;
    conSum = -INF;
    for(LL i = 0; i < n; i++) {
        for(LL j = i; j < n; j++) {
            LL sum = 0;
            for(LL k = i; k <= j; k++) {
                sum += a[k];
                tot++;
            }
            if(sum > conSum) {
                conSum = sum;
            }
        }
    }
    return conSum;
}

// n^2的演算法
LL maxConSumN2(LL *a, LL n) {
    tot = 0;
    conSum = -INF;
    for(LL i = 0; i < n; i++) {
        LL sum = 0;
        for(LL j = i; j < n; j++) {
            sum += a[j];
            tot++;
            if(sum > conSum) {
                conSum = sum;
            }
        }
    }
    return conSum;
}

// nlogn的演算法
// 採用分治法
// 對半劃分
// 遞迴求解左半邊和右半邊的最大連續和
// 遞迴邊界為left=right
// 求解左右連線部分的最大連續和
// 合併子問題：取三者最大值
LL division(LL *a, LL lef, LL righ) {
    // 遞迴邊界
    if(lef == righ) {
        return a[lef];
    }
    LL center = lef + (righ - lef) / 2;
    // 左半邊最大連續和

    LL maxLeftSum = division(a, lef, center);
    // 右半邊最大連續和
    LL maxRightSum = division(a, center + 1, righ);
    // 左連線部分最大和
    LL maxLeftConSum = -INF;
    LL leftConSum = 0;
    for(LL i = center; i >= lef; i--) {
        leftConSum += a[i];
        tot++;
        if(leftConSum > maxLeftConSum) {
            maxLeftConSum = leftConSum;
        }
    }
    // 右連線部分最大和
    LL maxRightConSum = -INF;
    LL rightConSum = 0;
    for(LL i = center + 1; i <= righ; i++) {
        rightConSum += a[i];
        tot++;
        if(rightConSum > maxRightConSum) {
            maxRightConSum = rightConSum;
        }
    }
    return max(max(maxLeftSum, maxRightSum), maxLeftConSum + maxRightConSum);
}

LL maxConSumNLogN(LL *a, LL n) {
    return division(a, 0, n - 1);
}

// n的演算法
LL maxConSumN(LL *a, LL n) {
    conSum = -INF;
    LL sum = 0;
    tot = 0;
    for(int i = 0; i < n; i++) {
        sum += a[i];
        tot++;
        if(sum < 0) {
            sum = 0;
        }
        if(sum > conSum) {
            conSum = sum;
        }
    }
    return conSum;
}

int main() {
    LL a[] = {-2, 3, 4, 5, -6, 7, -1, 2, 6};
    cout << "時間複雜度為N^3的演算法:" << maxConSumN3(a, 9);
    cout << "\t 計算次數為:" << tot << endl;

    cout << "時間複雜度為N^2的演算法:" << maxConSumN2(a, 9);
    cout << "\t 計算次數為:" << tot << endl;

    tot = 0;
    cout << "時間複雜度為NLogN的演算法:" << maxConSumNLogN(a, 9);
    cout << "\t 計算次數為:" << tot << endl;

    cout << "時間複雜度為N的演算法:" << maxConSumN(a, 9);
    cout << "\t\t 計算次數為:" << tot << endl;

    return 0;
}

輸出結果為

時間複雜度為N^3的演算法:20         計算次數為:165
時間複雜度為N^2的演算法:20         計算次數為:45
時間複雜度為NLogN的演算法:20       計算次數為:29
時間複雜度為N的演算法:20           計算次數為:9

Process returned 0 (0x0)   execution time : 0.196 s
Press any key to continue.

演算法競賽中的時間複雜度選擇

假設機器速度是每秒108次基本運算，運算量為n3、n2、nlog2n、n、2n（如子集列舉）和n!（如排列列舉）的演算法，在1秒之內能解決最大問題規模n，如表所示：

表還給出了機器速度擴大兩倍後，演算法所能解決規模的對比。可以看出，n!和2n不僅能解決的問題規模非常小，而且增長緩慢；最快的nlog2n和n演算法不僅解決問題的規模大，而且增長快。漸進時間複雜為多項式的演算法稱為多項式時間演算法（polymonial-time algorithm），也稱有效演算法；而n!或者2n這樣的低效的演算法稱為指數時間演算法（exponentialtime algorithm）。

不過需要注意的是，上界分析的結果在趨勢上能反映演算法的效率，但有兩個不精確性： 一是公式本身的不精確性。例如，“非主流”基本操作的影響、隱藏在大O記號後的低次項和最高項係數；二是對程式實現細節與計算機硬體的依賴性，例如，對複雜表示式的優化計算、把記憶體訪問方式設計得更加“cache友好”等。在不少情況下，演算法實際能解決的問題規模與表所示有著較大差異。

儘管如此，表還是有一定借鑑意義的。考慮到目前主流機器的執行速度，多數演算法競賽題目所選取的資料規模基本符合此表。例如，一個指明n≤8的題目，可能n!的演算法已經足夠，n≤20的題目需要用到2n的演算法，而n≤300的題目可能必須用至少n3的多項式時間演算法了。