[leetcode]Maximum Subarray (C语言)

问题描述
Find the contiguous subarray within an array (containing at least one number) which has the largest sum.

For example, given the array [−2,1,−3,4,−1,2,1,−5,4],
the contiguous subarray [4,−1,2,1] has the largest sum = 6.

这道题并不大难，从头开始遍历，如果是负的，就抛弃，继续，如果是正的，就将其加入。
代码如下：

int maxSubArray(int* nums, int numsSize) {
    int i,j;
    if(numsSize<=0)
        return 0;

    int max=0,realMax=nums[0];

    for(i = 0;imax+=nums[i];
        if(max<0){
            realMax = (realMax>max)?realMax:max;
            max = 0;
            continue;
        }
        realMax = (realMax>max)?realMax:max;
    }
    return realMax;
}

但是很奇怪的是：它题目中要求用divided&conquer方法实现一遍，这显然是需要使用2分法，但是它的复杂度大概是O(nlogn)的复杂度，实际测试时间，前者是4ms，后者是8ms，不知道为啥要多次一举
代码如下：

int dividedMax(int *nums,int start,int end){
    if(end-start==1)
        return nums[start];
    int mid = (start+end)/2;
    int max1 = dividedMax(nums,start,mid);
    int max2 = dividedMax(nums,mid,end);

    //处理中间部位
    int leftMax=nums[mid],tmpMax = 0,realMax;
    int i;
    for(i = mid;i>=start;i--){
        tmpMax+=nums[i];
        if(tmpMax>leftMax)
            leftMax = tmpMax;
    }
    tmpMax = 0;
    int rightMax=nums[mid];
    for(i = mid;iif(tmpMax>rightMax)
            rightMax = tmpMax;
    }
    realMax = leftMax+rightMax-nums[mid];

    max1 = (max1>max2)?max1:max2;
    realMax = (realMax>max1)?realMax:max1;

    return realMax;
}
int maxSubArray(int* nums, int numsSize) {
    return dividedMax(nums,0,numsSize);
}

更新：
开始做题的时候完全是靠“灵光一闪”，没有归纳，没有总结，没有提炼，直到看到[Code Ganker]的博客(http://blog.csdn.net/linhuanmars/article/details/21314059)
他将这道题归纳为动态规划算法。所谓动态规划指对于某个元素a[j],局部最优解为：local[j] = max(local[j-1]+a[j],a[j])，即取a[j]或者不取a[j]两种。而全局最优为global[j] = max(local[j],global[j-1]);
（注意：对于一般的动态规划，local[j] = max(local[j-1]+a[j],local[j-1]，但是对本题而言，如果前者为负的，那需要放弃并开始新的）
copy代码如下：

public int maxSubArray(int[] A) {  
    if(A==null || A.length==0)  
        return 0;  
    int global = A[0];  
    int local = A[0];  
    for(int i=1;ilength;i++)  
    {  
        local = Math.max(A[i],local+A[i]);  
        global = Math.max(local,global);  
    }  
    return global;  
}