【算法导论学习笔记】最大子数组问题

Maximum Subarray

要在一个数组中找出一个最大子数组，最直观的想法就是尝试所有可能的情况，从所有的子数组中找出和最大的子数组。这种方法的时间复杂度较高，下面采用分治算法来进行求解。

分治算法主要有三个步骤：

分解：将问题分解为一些子问题，子问题的形式与原问题一样，但规模更小；

解决：递归的求解子问题，如果子问题规模足够小，则停止递归；

合并：将子问题的解组合成原问题的解。

假如我们要寻找数组A[low...high]的最大子数组，利用分治策略，将子数组分解为规模尽量接近的两个子数组，比如在数组中间mid进行分解，分成A[low...mid]和A[mid...high]，再求解子数组的最大子数组。A[low...high]的最大子数组只有下面三种情况：

1.完全位于左子数组；

2.完全位于右子数组；

3.跨越中点。

下面是牛客网上的一道求最大子数组和的题：

HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。你会不会被他忽悠住？(子向量的长度至少是1)

class Solution {public:    int FindGreatestSumOfSubArray(vector<int> array) {    int low = 0;         int high = array.size() - 1;        return FindMaximunSubarray(array, low, high);    }    int FindMaximunSubarray(vector<int> array, int low, int high){        if(low == high){            return array[low];        }        else{            int mid = (low + high) / 2;            int leftSum = FindMaximunSubarray(array, low, mid);            int rightSum = FindMaximunSubarray(array, mid + 1, high);            int midSum = FindMaxCrossingSumOfSubArray(array, low, mid, high);            if(leftSum > rightSum){                if(leftSum > midSum) return leftSum;                else return midSum;            }            else if(rightSum > midSum) return rightSum;            else return midSum;        }    }    int FindMaxCrossingSumOfSubArray(vector<int> array, int low, int mid, int high){        int left_sum = array[mid - 1];        int sum = 0;        int right_sum = array[mid + 1];        int maxLeft = mid;        int maxRight = mid;        for(int i = mid - 1; i >= low; i--){            sum = sum + array[i];            if(sum > left_sum){                left_sum = sum;             maxLeft = i;            }        }        sum = 0;        for(int j = mid + 1; j <= high; j++){            sum = sum + array[j];            if(sum > left_sum){                right_sum = sum;             maxRight = j;            }        }        sum = left_sum + right_sum + array[mid];        return sum;    }};

通过的运行时间是3ms,运行内存是496K。看到排行榜好多时间内存都比我少的，看了看别人的代码，用的是动态规划。这样的话就只需要遍历整个数组一次，效率大大提高了。

class Solution {public:    int FindGreatestSumOfSubArray(vector<int> array) {                 int cursum=array[0];        int maxsum=array[0];        for(int i=1;i<array.size();i++){            cursum+=array[i];            if(cursum<array[i])                cursum=array[i];            if(cursum>maxsum)                maxsum=cursum;                   }    return maxsum;    }};

在网上看到一个写得很详细的博客：http://blog.csdn.net/liu2012huan/article/details/51296635