“《编程珠玑》（第2版）第8章”：连续子向量的最大和（扫描算法）

　　问题是这样子的：

　　输入是具有n个浮点数的向量x，输出是输入向量的任何子向量中的最大和。

　　本文部分参考自一博文。

　　对于这道题，作者给出了总共4种不同方法：

　 1. 直接解法

　　最直接的方式是遍历所有可能的连续子向量，用i和j分别表示向量的首元和最后的尾元，k表示真实的尾元：

int maxsum1(int * arr, int len)
{
    assert(len > 0);
    int maxsofar = 0;
    int sum = 0;
    for (int i = 0; i < len; i++)
    {
        for (int j = i; j < len; j++)
        {
            sum = 0;
            for (int k = i; k < j + 1; k++)
            {
                sum += *(arr + k);
            }
            maxsofar = max(maxsofar, sum);
        }
    }
    return maxsofar;
}

　 2. O(n²)的解法

　　第1种方法的代码具有显而易见的浪费：对于一个子序列可能重复计算了多次。并且具有O(n³)的时间复杂度。其实k是多余的，依靠首尾两个变量i、j足以表示一个子向量。同时，j增长时，可以直接使用上一次的计算和与新增元素相加。因此改写为：

int maxsum2(int * arr, int len)
{
    assert(len > 0);
    int maxsofar = 0;
    int sum = 0;
    for (int i = 0; i < len; i++)
    {
        sum = 0;
        for (int j = i; j < len; j++)
        {
            sum += *(arr + j);
            maxsofar = max(maxsofar, sum);
        }
    }
    return maxsofar;
}

　　另外一方面，由这个避免重复计算累加和的角度出发，构造一个累加和数组cumarr，cumarr[i]表示array[0...i]各个数的累加和，这样，array[i...j]的和就可以用cumarr[j]-cumarr[i-1]来表示了。考虑到边界值，令cumarr[-1]=0。在C/C++中的做法是令cumarr指向一个数组的第1个元素，cumarr = recumarr +1。有了cumarr[]就可以遍历所有的i、j来求最大值了：

int maxsum3(int * arr, int len)
{
    assert(len > 0);
    int maxsofar = 0;
    int sum = 0;
    int * cumarr = new int[len + 1];
    cumarr[0] = 0;
    for (int i = 0; i < len; i++)
    {
        cumarr[i + 1] = cumarr[i] + *(arr + i);
    }

    for (int i = 0; i < len; i++)
    {
        for (int j = i; j < len; j++)
        {
            sum = cumarr[j + 1] - cumarr[i];
            maxsofar = max(maxsofar, sum);
        }
    }

    delete cumarr;
    return maxsofar;
}

　　虽然这个累加和数组的解法与后面两个相比，时间复杂度远不是最优的，然而这种数据结构很有用。

　　累积表这种想法值得注意！

　 3. 分治法(nlogn)

　　分治法的基本思想是，把n个元素的向量分成两个n/2的子向量，递归地解决问题再把答案合并。

　　分容易，合并就要花点心思了。因为对于初始大小为n的向量，它的最大连续子向量可能整体在分成的两个子向量中之一，也可能跨越了两个子向量。每次合并都需要计算这个跨越分界点的最大连续子向量，占据了很大的开销。

int maxsum4(int * arr, int len)
{
    assert(len > 0);
    int maxsofar = 0;
    if (len == 1)
    {
        maxsofar = arr[0];
    }
    else
    {
        int sum = 0;
        int l = 0;
        int u = len - 1;
        int m = (l + u) / 2;

        // find max crossing to left
        int lmax = 0;
        for (int i = m; i >= 0; i--)
        {
            sum += *(arr + i);
            lmax = max(lmax, sum);
        }

        // find max crossing to right
        int rmax = 0;
        sum = 0;
        for (int i = m + 1; i <= u; i++)
        {
            sum += *(arr + i);
            rmax = max(rmax, sum);
        }

        maxsofar = max(lmax + rmax, maxsum4(arr, m + 1), maxsum4(arr + m + 1, u - m));
    }

    return maxsofar;
}

　　延伸：分治法的最坏情况讨论

　　根据合并过程，如果每次的最长子向量都恰好位于边界，即下图中灰色部分，两者其中之一：

　　

　　结果导致每次合并时都重复计算了在左边和右边的最长子向量，相当的浪费。解决方法是返回值中给出边界，如果边界在分界点上，合并时就不需要重复计算了。

　 4. 扫描算法

　　从头到尾扫描数组，扫描至array[i]时，可能的最长子向量有两种情况：要么在前i-1个元素中，要么以i结尾。前者的大小记为maxsofar，后者记为maxendinghere。

int maxsum5(int * arr, int len)
{
    assert(len > 0);
    int maxsofar = 0;
    int maxendinghere = 0;
    for (int i = 0; i < len; i++)
    {
        maxendinghere = max(maxendinghere + *(arr + i), 0);
        maxsofar = max(maxsofar, maxendinghere);
    }
    return maxsofar;
}

　　这个算法可以看做是动态规划，把长度为n的数组化成了递归的子结构，并从首开始扫描求解。时间复杂度只有O(n)。

　　注：直到最近做到LeetCode的题目，才发现这个扫描算法并不适用于存在负数的数组。对于存在负数的数组，可用下述解法：

    int maxSubArray(vector<int>& nums) {
        int sz = nums.size();
        if(sz == 0)
            return 0;
            
        int maxsofar = INT_MIN;
        int sum = 0;
        for(int i = 0; i < sz; i++)
        {
            sum += nums[i];
            if(sum > maxsofar)
                maxsofar = sum;
            if(sum < 0)
                sum = 0;
        }
        
        return maxsofar;
    }

　　

　　同样的，利用该算法，我们还可以求总共最小的连续子向量：

int minsum(int * arr, int len)
{
    assert(len > 0);
    int minsofar = 0;
    int minendinghere = 0;
    for (int i = 0; i < len; i++)
    {
        minendinghere = min(minendinghere + *(arr + i), 0);
        minsofar = min(minsofar, minendinghere);
    }

    return minsofar;
}

　　

　　附整个程序：

#include <iostream>
#include <stdlib.h>
#include <cassert>
using namespace std;

int max(int a, int b);
int max(int a, int b, int c);
int min(int a, int b);

int maxsum1(int * arr, int len);
int maxsum2(int * arr, int len);
int maxsum3(int * arr, int len);
int maxsum4(int * arr, int len);
int maxsum5(int * arr, int len);

int minsum(int * arr, int len);

int main()
{
    int arr[8] = {5, -2, -3, 4, -2, -8, 10, -5};
    int len = sizeof(arr) / sizeof(int);

    int maxsofar1 = maxsum1(arr, len);
    cout << "Maxsofar1 = " << maxsofar1 << endl;

    int maxsofar2 = maxsum2(arr, len);
    cout << "Maxsofar2 = " << maxsofar2 << endl;

    int maxsofar3 = maxsum3(arr, len);
    cout << "Maxsofar3 = " << maxsofar3 << endl;

    int maxsofar4 = maxsum4(arr, len);
    cout << "Maxsofar4 = " << maxsofar4 << endl;

    int maxsofar5 = maxsum5(arr, len);
    cout << "Maxsofar5 = " << maxsofar5 << endl;

    int minsofar = minsum(arr, len);
    cout << "Minsofar = " << minsofar << endl;

    return 0;
}

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

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

int min(int a, int b)
{
    return (a < b) ? a : b;
}

int maxsum1(int * arr, int len)
{
    assert(len > 0);
    int maxsofar = 0;
    int sum = 0;
    for (int i = 0; i < len; i++)
    {
        for (int j = i; j < len; j++)
        {
            sum = 0;
            for (int k = i; k < j + 1; k++)
            {
                sum += *(arr + k);
            }
            maxsofar = max(maxsofar, sum);
        }
    }
    return maxsofar;
}

int maxsum2(int * arr, int len)
{
    assert(len > 0);
    int maxsofar = 0;
    int sum = 0;
    for (int i = 0; i < len; i++)
    {
        sum = 0;
        for (int j = i; j < len; j++)
        {
            sum += *(arr + j);
            maxsofar = max(maxsofar, sum);
        }
    }
    return maxsofar;
}

int maxsum3(int * arr, int len)
{
    assert(len > 0);
    int maxsofar = 0;
    int sum = 0;
    int * cumarr = new int[len + 1];
    cumarr[0] = 0;
    for (int i = 0; i < len; i++)
    {
        cumarr[i + 1] = cumarr[i] + *(arr + i);
    }

    for (int i = 0; i < len; i++)
    {
        for (int j = i; j < len; j++)
        {
            sum = cumarr[j + 1] - cumarr[i];
            maxsofar = max(maxsofar, sum);
        }
    }

    delete cumarr;
    return maxsofar;
}

int maxsum4(int * arr, int len)
{
    assert(len > 0);
    int maxsofar = 0;
    if (len == 1)
    {
        maxsofar = arr[0];
    }
    else
    {
        int sum = 0;
        int l = 0;
        int u = len - 1;
        int m = (l + u) / 2;

        // find max crossing to left
        int lmax = 0;
        for (int i = m; i >= 0; i--)
        {
            sum += *(arr + i);
            lmax = max(lmax, sum);
        }

        // find max crossing to right
        int rmax = 0;
        sum = 0;
        for (int i = m + 1; i <= u; i++)
        {
            sum += *(arr + i);
            rmax = max(rmax, sum);
        }

        maxsofar = max(lmax + rmax, maxsum4(arr, m + 1), maxsum4(arr + m + 1, u - m));
    }

    return maxsofar;
}

int maxsum5(int * arr, int len)
{
    assert(len > 0);
    int maxsofar = 0;
    int maxendinghere = 0;
    for (int i = 0; i < len; i++)
    {
        maxendinghere = max(maxendinghere + *(arr + i), 0);
        maxsofar = max(maxsofar, maxendinghere);
    }
    return maxsofar;
}

int minsum(int * arr, int len)
{
    assert(len > 0);
    int minsofar = 0;
    int minendinghere = 0;
    for (int i = 0; i < len; i++)
    {
        minendinghere = min(minendinghere + *(arr + i), 0);
        minsofar = min(minsofar, minendinghere);
    }

    return minsofar;
}

　课后相关习题

　　10. 假设我们想要查找的是总和最接近0的子向量，而不是具有最大总和的子向量。你能设计出的最有效的算法是什么？可以应用哪些算法设计技术？如果我们希望查找总和最接近某一给定实数t的子向量，结果又将怎样？

　　法一：利用累积表。我们定义cumarr[i]=arr[0]+arr[0]+...+arr[i]。如果有arr[l]=arr[u]（l != u），则l..u之间的元素（不包括第l、u元素）总和为0。这个就也能够拓展到查找总和接近某一给定实数t的子向量。

　　法二：如果我们不考虑子向量一定要连续这个要求，我们可以先将原向量按升序进行排序，再求cumarr向量。如果cumarr[i]=0，则表示0..i（包括第0、i元素）为所求子向量。这个同样也能够拓展到查找总和接近某一给定实数t的子向量。

 　　注：此题若用扫描算法来解决，问题比较多。

　　13. 在最大子数组问题中，给定n*n的实数数组，我们需要求出矩形子数组的最大总和。该问题的复杂度如何？

　　个人觉得很简单的就是把二维的降为一维的。如果是要求连续子向量，按照扫描算法就可以做到；如果不要求连续，则先按降序进行排序，很快就能够求出最大总和的子向量。