最大子数组和（The Maximum Subarray）

问题：求一个整型数组的（1）最大连续子数组和以及（2）不要求连续的最大子数组和

要求 返回的结果不能使空数组。

解答思路：

（1）从前往后扫描数组，当前边累加的和大于零的时候，说明这个序列对结果有益，则保留，并且加上当前数组元素A[i]。如果当前累加的和小于等于0，说明已经扫描序列会降低结果的值，有害，则抛弃，当前最大结果则为当前元素A[i]。该算法的时间复杂度是O(n).

      但是这样做，当所有的元素都是负数的时候，算法选择的子数组是空的，故此时需要返回最大的负数。

（2） 只需要选择所有的整数并相加则可以。如果这样的结果是0，则返回最大的负数即可。

Sample Input

2 
4 
1 2 3 4
6
2 -1 2 3 4 -5

Sample Output

10 10
10 11

我的解答：

import java.io.*;
import java.util.*;

public class TheMaximumSubArray{
	public static void main(String[] args){
		Scanner scan = new Scanner(System.in);
		int T = scan.nextInt();
		scan.nextLine();
		for(int i = 0; i < T; i ++){
			int N = scan.nextInt();
			
			// input a array of data
			int[] numbers = new int[N];
			for(int j = 0; j < N; j++){
				// System.out.print(j);
				numbers[j] = scan.nextInt();
			}

			// DP
			// 1. Contiguous subarray
			int maxResult = 0;
			int result1 = 0; //temp
			int maxResultNagtive = Integer.MIN_VALUE;
			for(int k = 0; k < N; k ++){
				if(result1 < 0){
					result1 = numbers[k];
				}
				else{
					result1 += numbers[k];
				}
				if(result1 > maxResult){
					maxResult = result1;
				}

				// keep the smallest negative number 
				if(numbers[k] < 0 && numbers[k] > maxResultNagtive){
					maxResultNagtive = numbers[k];
				}
			}
			// if no positive result found, return the 
			if(maxResult == 0){
				maxResult = maxResultNagtive;
			}	


			//2. Not necessarily contiguous
			int maxResult2 = 0;
			int maxResultNagtive2 = Integer.MIN_VALUE;
			for(int m = 0; m < N; m ++){
				if(numbers[m] > 0){
					maxResult2 += numbers[m];
				}

				if(numbers[m] < 0 && numbers[m] > maxResultNagtive2){
					maxResultNagtive2 = numbers[m];
				}
			}
			if(maxResult2 == 0){
				maxResult2 = maxResultNagtive2;
			}

			// output
			System.out.print(maxResult); 
			System.out.print(" ");
			System.out.println(maxResult2);
			// System.out.println(Arrays.toString(numbers));
			// scan.nextLine();
		}
		scan.close();
	}
}