连续最大和 三种解法

题目描述：

    一个数组有 N 个元素，求连续子数组的最大和。 例如：[-1,2,1]，和最大的连续子数组为[2,1]，其和为 3。

第一种解法---暴力法:

    直接枚举出所有的可能性，然后找到和最大的即可，这里用到了arraylist这个数据结构。

public class Main {


    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        String s=scanner.nextLine();
        String str=scanner.nextLine();

        String[] str2=str.split(" ");
        int[] index=new int[str2.length];
        for(int i=0;i<str2.length;i++)
            index[i]=Integer.valueOf(str2[i]);
        int max= -2147483648;
        for(int i=0;i<index.length;i++){
            ArrayList<Integer> list=new ArrayList<>();
            for(int j=i;j<index.length;j++){
                list.add(index[j]);
                int sum=sum(list);
                if(sum>max){
                    max=sum;
                }
            }
        }
        System.out.println(max);

    }

    public static int sum( ArrayList<Integer> list){
        int sum=0;
        for(Integer integer:list){
            sum+=integer;
        }
       return sum;
    }

}

第二种方法

     根据题意，可以维护一个二维数组，f[i][j]表示第i个数为起点，连续j个数的和。

      f[i][j]=f[i][j-1]+a[j]，最后只要找到二维数组里面的最大值即可。

public class Main13 {

    public static void main(String[] args){

        String str="1 -2 3 10 -4 7 2 -5";
        String[] s=str.split(" ");
        int length=s.length;
        int[] a=new int[length+1];
        for(int i=1;i<=length;i++) {
             a[i]=Integer.valueOf(s[i-1]);
        }
        int[][] f=new int[length+1][length+1];
        int max= -2147483648;
        for(int i=1;i<=length;i++){
            for(int j=i;j<=length;j++){
                     if(i==j) {
                         f[i][j] = a[i];
                         if(max<f[i][j]){
                             max=f[i][j];
                         }
                         continue;
                     }
                     f[i][j]=f[i][j-1]+a[j];

                     if(max<f[i][j]){
                        max=f[i][j];
                     }
                }
            }

            System.out.println(max);

        }
}

第三种方法---动态规划

    维护一个数组 f[i] 表示以i为结尾的连续数组的最大值。

    当i=0时，f[i]=a[i]。

   当i!=0时，分为两种情况

   1) f[i-1]>0时，f[i]=f[i-1]+a[i]

   2) f[i-1]<0时，f[i]=a[i] 

 代码如下:

        

public class Main14 {

    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        String len2=scanner.nextLine();
        String str=scanner.nextLine();
        String[] s=str.split(" ");
        int len=s.length;
        int[] a=new int[len];
        for(int i=0;i<len;i++){
            a[i]=Integer.valueOf(s[i]);
        }
        int[] f=new int[len];
        int max= -2147483648;
        for(int i=0;i<len;i++){
            if(i==0){
                f[0]=a[0];
                if(max<f[0]) max=f[0];
                continue;
            }
            if(f[i-1]>0){
                f[i]=f[i-1]+a[i];
                if(max<f[i]) max=f[i];
            }else{
                f[i]=a[i];
                if(max<f[i]) max=f[i];
            }

        }

        System.out.println(max);
    }

}

不难发现，采用动态规划的方式，不管在时间还是在空间上的消耗都是最小的。