剑指offer——连续子数组的最大和（动规或者普通算法，不错）

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

思路：
一开始想到要动态规划，但发现必须是连续向量，用动态规划可能更麻烦。

思路是，从数组中第一个为正数的元素开始，一直往后加上元素，同时维护一个max变量和一个now变量。当now小于0时，停止。找到下一个正数，重复上述操作。（但是如果碰到全负数的情况会比较麻烦，变成寻找一个数组中的最大值了）

还是先用动态规划做。下标为n的元素a，到这个元素的最大连续子向量和有4种情况

当a大于等于0的情况比较简单。
当a小于0时，若a加上之前的最大连续子元素和大于等于0，则为和的值。
若不是，则直接把a这个位置的最大连续子元素和置为a。

特殊情况是全为负数的情况，因为我们做了上述直接置为a的处理，所以全为负数的时候，就不会出现加操作。

动规法：

public class Solution {
    public int FindGreatestSumOfSubArray(int[] array) {
        if(array==null||array.length==0)
            return 0;
        int[] result = new int[array.length];
        result[0] = array[0];
        for(int i = 1; i<array.length; i++){
            if(array[i]>=0){
                if(result[i-1]>=0)
                    result[i] = result[i-1]+array[i];
                else
                    result[i] = array[i];
            }
            else{
                if(array[i]+result[i-1]>=0)
                    result[i] = array[i]+result[i-1];
                else
                    result[i] = array[i];
            }
        }
        int max = result[0];
        for(int i = 1; i<array.length; i++){
            if(result[i]>max)
                max = result[i];
        }
        return max;
    }
}

public class Solution {
    public int FindGreatestSumOfSubArray(int[] array) {
        if(array==null||array.length==0)
            return 0;
        int[] result = new int[array.length];
        result[0] = array[0];
        
        for(int i = 1; i < array.length; i++){
            int temp = array[i] + result[i-1];
            if(temp < array[i]){
                result[i] = array[i];
            } else {
                result[i] = temp;
            }
        } 
        int max = result[0];
        for(int i = 0; i < result.length; i++){
            if(result[i] > max){max = result[i];}
        }
        return max;
    }
    
    
}

之前的动归复杂了，其实一次循环就够了

public class Solution {
    public int FindGreatestSumOfSubArray(int[] array) {

        int res = array[0]; //记录当前所有子数组的和的最大值
        int max=array[0];   //包含array[i]的连续数组最大值
        for (int i = 1; i < array.length; i++) {
            max=Math.max(max+array[i], array[i]);
            res=Math.max(max, res);
        }
        return res;
}
}

=============================
最开始的思路也是可以的。

    public int FindGreatestSumOfSubArray(int[] array) {
        if(array==null||array.length==0)
            return 0;
        int max = 0;
        int now = 0;
        int i = 0;
        while(i<array.length){
            while(i<array.length&&array[i]<0){
                i++;
            }
            if(i<array.length){
                now = array[i];
                max = array[i];
                for(++i; i<array.length; i++){
                    if(now<0)
                        break;
                    now += array[i];
                    if(now > max)
                        max = now;
                }
            }
        }
        if(max>0)
            return max;
        else{
            max = array[0];
            for(int j = 0; j<array.length; j++)
                if(array[j]>max)
                    max = array[j];
        }
        return max;
    }