樓主這篇文章的目的是要帶大家梳理一下，有關於求子陣列問題。如求子陣列的最大和，求最大和的子陣列，求最大積的子陣列等一系列問題。今天陽光明媚，樓主今天心情很好哦，願大家開心每一天，哈哈。Are you ready?開始了哦~~~

題目一：求子陣列的最大和

題目求子陣列的最大和，這裡需要注意的一個問題就是，子陣列那麼便意味著是連續的一段資料。我們可以先寫的例子，方便我們注意到要考慮的一些問題。

陣列：[1, -2, 3, 5, -3, 2] 應該返回8，最大和的子陣列為3，5
陣列：[0, -2, 3, 5, -1, 2] 應該返回9，最大和的子陣列為3, 5，-1，2
陣列：[-1, -2, -3, -4, -5]應該返回-1，最大和的子陣列為-1
這裡，我們只介紹一種時間複雜度為O

(N)的演算法來求解。

解法一：分治法

將所給陣列(A[0],A[1],...,A[N−1])分成兩組，(A[0],A[1],...,A[N2−1])和(A[N2],A[N2+1],...,A[N−1])，分別求出這兩段陣列各自的最大子段和，則原陣列的子陣列的最大和可以分為下面三種情況：

和(A[0],A[1],...,A[N2−1])相同
和(A[N2],A[N2+1],...,A[N−1])相同
跨過中間兩個元素A[N2−1])和A[N2])。

看下面程式碼：

#include <iostream>  
#include <limits>

using namespace 
 std;  

int getMAX3(int a, int b, int c);
int getBiggestSubSum(int *pArray, int low, int high);

int main()  
{  
    int a1[] = {1, -2, 3, 5, -3, 2};
    int a2[] = {1, -2, 3, 5, -1, 2};
    int a3[] = {-1, -2, -3, -5, -3, -2};

    cout << "陣列1的子數子的最大和為" << getBiggestSubSum(a1, 0, sizeof(a1) / sizeof(int 
) - 1) << endl;
    cout << "陣列2的子數子的最大和為" << getBiggestSubSum(a2, 0, sizeof(a2) / sizeof(int) - 1) << endl;
    cout << "陣列3的子數子的最大和為" << getBiggestSubSum(a3, 0, sizeof(a3) / sizeof(int) - 1) << endl;
    system("pause");
}  

int getBiggestSubSum(int *pArray, int low, int high)
{
    int middle = (low + high) >> 1; //獲取中間節點的下標
    int MAX = numeric_limits<int>::min();
    if (high == low)
    {
        //遞迴到只剩下一個數之後，那麼直接返回
        return pArray[low];
    }

    int lMax = numeric_limits<int>::min(); 
    int rMax = numeric_limits<int>::min(); 
    int mMax = numeric_limits<int>::min(); 
    int mMaxTemp = 0;

    //求左半部分的最大和
    lMax = getBiggestSubSum(pArray, low, middle);
    //求右半部分的最大和
    rMax = getBiggestSubSum(pArray, middle + 1, high);

    //求橫跨中間的最大和
    for (int i = middle; i <= high; i++)
    {
        mMaxTemp += pArray[i];
        mMax = max(mMax, mMaxTemp);
    }

    for (int i = middle - 1; i >= 0; i--)
    {
        mMaxTemp += pArray[i];
        mMax = max(mMax, mMaxTemp);
    }

    //返回三大部分最大和之間的最大值
    return getMAX3(rMax, mMax, lMax);
}

int getMAX3(int a, int b, int c)
{
    int max = a;
    max = (b > max) ? (b):(max);
    max = (c > max) ? (c):(max);
    return max;
}

演算法複雜度：O(NlogN)。

解法二：動態規劃法

我們可以考慮陣列的第一個元素A[0]，以及最大的一段陣列(A[i],...,A[j])跟$A[0]的關係，有以下幾種情況：

i = 0 = j，這便意味著，最大和的子陣列只由一個A[0]組成；
0 = i < j，這便意味著，最大和的子陣列是從A[0]開始的一串序列組成；
0 < i < j，這便意味著，最大和的子陣列和A[0]無關，不是從A[0]開始的。

從上面三種情況可以看出來，我們可以將一個大問題，轉化成一個較小的問題。如本題中，我們可以將一個N維陣列的子陣列最大和問題，轉化成N-1維的子陣列最大和問題。假設已經知道(A[1],...,A[N−1])子陣列的最大和為All[1]，還知道包含A[1]的子陣列的最大和為Start[1]。那麼根據上面的分析可知

All[0]=max{A[0],A[0]+Start[0],All[1]}

上述公式中，第一項表示只有一個A[0]元素構成最大和子陣列，第二項表示A[0]和從A[1]開始的序列構成最大和子陣列，第三項表示，最大和子陣列和A[0]無關。看下面程式碼：

#include <iostream>  

using namespace std;  

int getBiggestSubSum(int *pArray, int len);

int main()  
{  
    int a1[] = {1, -2, 3, 5, -3, 2};
    int a2[] = {1, -2, 3, 5, -1, 2};
    int a3[] = {-1, -2, -3, -5, -3, -2};

    cout << "陣列1的子數子的最大和為" << getBiggestSubSum(a1, sizeof(a1) / sizeof(int)) << endl;
    cout << "陣列2的子數子的最大和為" << getBiggestSubSum(a2, sizeof(a2) / sizeof(int)) << endl;
    cout << "陣列3的子數子的最大和為" << getBiggestSubSum(a3, sizeof(a3) / sizeof(int)) << endl;
    system("pause");
}  

int getBiggestSubSum(int *pArray, int len)
{
    //從陣列的最後一個元素開始,當只有一個元素的時候，那麼start和all當然都是等於這個數啦
    int nStart = pArray[len - 1];
    int nAll = pArray[len - 1];

    for (int i = len - 2; i >= 0; i--)
    {
        nStart = max(pArray[i], nStart + pArray[i]);
        nAll = max(nAll, nStart);
    }
    return nAll;
}

執行結果：

陣列1的子數子的最大和為8
陣列2的子數子的最大和為9
陣列3的子數子的最大和為-1
請按任意鍵繼續. . .

演算法複雜度：O(NlogN)

題目二：求子陣列的最大和並輸出相應的子陣列

題目一隻管求出子陣列的最大和，不管子陣列是什麼。而這個題目中，我們需要求解子陣列序列的起始位置和結束位置。其實和上面差不多，只是需要記錄位置而已，看程式碼，在題目一的解法二上面修改的。

#include <iostream>  

using namespace std;  

int getBiggestSubSum(int *pArray, int len, int *startIndex, int *endIndex);
void printMaxSubArray(int *pArray, int start, int end);

int main()  
{  
    int a1[] = {1, -2, 3, 5, -3, 2};
    int a2[] = {1, -2, 3, 5, -1, 2};
    int a3[] = {-1, -2, -3, -5, -3, -2};

    int start = 0;
    int end = 0;

    cout << "陣列1的子數子的最大和為" << getBiggestSubSum(a1, sizeof(a1) / sizeof(int), &start, &end) << endl;
    cout << "和最大的子序列為" << endl;
    printMaxSubArray(a1, start, end);

    cout << "陣列2的子數子的最大和為" << getBiggestSubSum(a2, sizeof(a2) / sizeof(int), &start, &end) << endl;
    cout << "和最大的子序列為" << endl;
    printMaxSubArray(a2, start, end);
    cout << "陣列3的子數子的最大和為" << getBiggestSubSum(a3, sizeof(a3) / sizeof(int), &start, &end) << endl;
    cout << "和最大的子序列為" << endl;
    printMaxSubArray(a3, start, end);
    system("pause");
} 


int getBiggestSubSum(int *pArray, int len, int *startIndex, int *endIndex)
{
    //從陣列的最後一個元素開始,當只有一個元素的時候，那麼start和all當然都是等於這個數啦
    int nStart = pArray[len - 1];
    int nAll = pArray[len - 1];
    *startIndex = len - 1;
    *endIndex = len - 1;

    for (int i = len - 2; i >= 0; i--)
    {
        if (pArray[i] > nStart + pArray[i]) 
        {       
            nStart = pArray[i];
            if (nStart > nAll)
            {
                //如果僅僅包含pArray[i]的子序列獲得最大和的話，那麼startIndex和endIndex和nAll都需要更新
                *startIndex = i;
                *endIndex = i;
                nAll = pArray[i];
            }
            else
            {
                //還是原來的子序列和最大，那startIndex和endIndex都不變了
            }
        }
        else
        {
            nStart = nStart + pArray[i];
            if (nStart > nAll)
            {
                //如果包含a[i],a[i+1],...a[j]獲得最大的和的話，那麼要更新startIndex和nAll
                nAll = nStart;
                *startIndex = i;
            }
            else
            {
                //還是原來的子序列和最大，那startIndex和endIndex都不變了
            }
        }
    }
    return nAll;
}

void printMaxSubArray(int *pArray, int start, int end)
{
    for (int i = start; i <= end; i++)
    {
        cout << pArray[i] << " ";
    }
    cout << endl;
}

時間複雜度同樣是O(N)。

題目三：求子陣列的最大積

這裡必須要重述一下題目，和題目一以及題目二是不一樣的！！！！

給定一個長度為N的整數陣列，只允許用乘法，不能用除法，計算任意N-1個數的組合乘積中的最大的一組，並寫出演算法的時間複雜度。

這裡的子陣列，是任意N-1個數的組合，並不一定是連續的N-1的子序列。

解法一

其實這道題，騰訊某年筆試題的加試題就有這道題，感興趣的同學可以看這個連結2012年騰訊實習生筆試附加題
題目簡介：已知陣列a[n],求陣列b[n].要求：b[i]=a[0]a[1]……*a[n-1]/a[i]，不能用除法。a.時間複雜度O(n),空間複雜度O(1)。 b.除了迭代器i,不允許使用任何其它變數（包括棧臨時變數等），看，是不是差不多？

這裡我們同樣可以使用前累乘後累乘的辦法把所有的b[i]求出來，然後遍歷一遍，求出最大的積。看程式碼：

#include <iostream>  

using namespace std;  

void getBiggestMultipleResults(int *pArray, int *pResultsArray, int len);

int main()  
{  
    int a[] = {1, 2, 3, 4};
    int len = sizeof(a) / sizeof(int);
    int *b = new int[len]();
    int result = b[0];

    //求出所有的b[i]
    getBiggestMultipleResults(a, b, len);

    for (int i = 0; i < len; i++)
    {
        result = max(b[i], result);
    }

    cout << result << endl;

    delete []b;
    system("pause");
} 


void getBiggestMultipleResults(int *pArray, int *pResultsArray, int len)
{
    pResultsArray[0] = 1;
    //前累乘
    for (int i = 1; i < len; i++)
    {
        pResultsArray[i] = pResultsArray[i - 1] * pArray[i - 1];
    }

    //後累乘
    for (int i = len - 2; i > 0; i--)
    {
        //把pResultsArray[0]作為臨時變數
        pResultsArray[0] *= pArray[i + 1];
        pResultsArray[i] *= pResultsArray[0];
    }

    pResultsArray[0] *= pArray[1];
}

解法二：數學分析法

看完這個數學分析的方法，不禁感嘆，還是要數學好啊！不信，你看吧。

假設N個證書的乘積為P，針對P的正負性進行分析：

1. P=0

那麼，陣列中至少有1個0。除去這個0之外，其他N-1個數的乘積為Q，根據Q的正負性進行分析：

Q = 0

結果返回0.
分析：Q=0說明Q數組裡面還有1個0，加上前面P陣列中的1個0，我們可以斷定，任意N-1個數的乘積只能為0，那麼結果返回0.

Q > 0

結果返回Q
分析：如果以0替換此時Q數組裡面任意一個數的話，那麼結果都是0，所以最後結果為Q

Q < 0

結果返回0
分析：如果以0替換此時Q數組裡面的任意一個，則結果為0,0比負數大，所以結果返回0

2. P > 0

從陣列中去除一個絕對值最小的正整數，這樣得到剩下的

程式設計之美4：那些常被考到的關於陣列的最大子陣列問題

題目一：求子陣列的最大和

解法一：分治法

解法二：動態規劃法

題目二：求子陣列的最大和並輸出相應的子陣列

題目三：求子陣列的最大積

解法一

解法二：數學分析法

1. P=0

2. P > 0

程式設計之美4：那些常被考到的關於陣列的最大子陣列問題

程式設計之美4：階乘相關

程式設計之美1：那些關於1的個數的經典面試題

程式設計之美7：字串，那些你必須要會的事。

程式設計之美10：計算字串的相似度

程式設計之美9：陣列迴圈位移

程式設計之美8：求陣列的子陣列之和的最大值

程式設計之美7：最大公約數

程式設計之美3：求二進位制數中1的個數

程式設計之美2：程式只用一個位元組變數，列印將帥位置

程式設計之美1：CPU列印直線，曲線

程式設計之美8：連結串列常見面試筆試題集合

程式設計之美4.3 買票找零

程式設計之美6：陣列迴圈移位

程式設計之美2：尋找最大的K個數

程式設計之美4.3買票找零

程式設計之美-1.4-買書問題

程式設計之美：求二進位制中1的個數

Java 併發程式設計之美：併發程式設計高階篇之一-chat

Python書籍推薦：《Python程式設計之美：最佳實踐指南》

程式設計之美4：那些常被考到的關於陣列的最大子陣列問題

題目一：求子陣列的最大和

解法一：分治法

解法二：動態規劃法

題目二：求子陣列的最大和並輸出相應的子陣列

題目三：求子陣列的最大積

解法一

解法二：數學分析法

1. P=0

2. P > 0

相關推薦