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

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