连续子数组和最大问题

参考博文：

http://www.cnblogs.com/en-heng/p/3970231.html

http://www.cnblogs.com/jy02414216/archive/2012/08/20/2648102.html

还有DP解法、扫描法以及分治法。待后续更新。

---

//连续子数组和最大问题
//test case
//[31,-41,59,26,-53,58,97,-93,-23,84]
//59+26+(-53)+58+97=187和最大

public class Solution {
    private static int a[] = new int[] {-1,-2,-3};

    public static void main(String[] args) {
        // long startTime = System.currentTimeMillis();
        int res = method5(a);
        // long endTime = System.currentTimeMillis();
        // System.out.println("执行时间为：" + (endTime - startTime) + "ms");
        System.out.println(res);

    }

    /**
     * 穷举法 三层循环，时间复杂度为O(n^3)
     */
    public static int method1(int[] a) {
        int sum;
        int max = Integer.MIN_VALUE;
        int n = a.length;
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                sum = 0;
                for (int k = i; k <= j; k++) {
                    sum += a[k];
                }
                /* sum is sum of a[i...j] */
                max = Math.max(max, sum);
            }
        }
        return max;
    }

    /**
     * 对穷举法的改进1 时间复杂度为O(n^2)
     */
    public static int method2(int[] a) {
        int n = a.length;
        int sum;
        // cumarr为累加数组，如cumarr[5]记录了数组前6项之和
        int cumarr[] = new int[n];
        cumarr[0] = a[0];
        for (int i = 1; i < n; i++) {
            cumarr[i] = cumarr[i - 1] + a[i];
        }

        int max = Integer.MIN_VALUE;
        // a[i...j]之和 = cumarr[j]-cumarr[i-1]
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                sum = 0;
                if (i == 0) {
                    sum = cumarr[j];
                } else {
                    sum = cumarr[j] - cumarr[i - 1];
                }
                max = Math.max(max, sum);
            }

        }
        return max;
    }

    /**
     * 对穷举法的改进2
     * 时间复杂度为O(n^2)
     */
    public static int method3(int[] a) {
        int max = Integer.MIN_VALUE;
        int sum;
        int l = a.length;
        for (int i = 0; i < l; i++) {
            sum = 0;
            for (int j = i; j < l; j++) {
                sum += a[j];
                if (sum > max) {
                    max = sum;
                }
            }
        }
        return max;
    }


    public static boolean isAllNegative(int[] a) {
        for (int i = 0; i < a.length; i++) {
            if (a[i] > 0) {
                return false;
            }
        }
        return true;
    }

    /**
     * 貌似这个是Kadane算法？
     * 算法依据： 假如数组元素全为正数，那么最大值必然为全部数相加
     * 假如数组中有负数，如果加上某个负数，子数组和小于0，那么最大和的子数组必然不包括这个负数
     * 时间复杂度为O(n)
     */
    public static int method4(int[] a) {
        // 数组元素全部为负数的情况
        if (isAllNegative(a)) {
            return a[0];
        }
        int max = 0, temp = 0;
        for (int i = 0; i < a.length; i++) {
            temp += a[i];
            if (temp < 0) {
                temp = 0;
            } else {
                if (temp > max) {
                    max = temp;
                }
            }
        }
        return max;
    }
    
    /**
     * 动态规划的后无效性
     * 时间复杂度为O(n)
     */
    public static int method5(int [] array){
        int n=array.length;  
        int all=array[n-1],start=array[n-1];  
        int count=0;  
        for(int i=n-2;i>=0;i--){  
            if((start+array[i])>array[i]){  
                start=start+array[i];  
            }else{  
                start=array[i];  
            }  
            if(all<start){  
                all=start;  
            }  
            count++;  
        }  
        System.out.println("数组长度="+array.length+"||时间复杂度="+count);    
        return all;  
    }
}