LintCode : 最接近零的子数组和 Subarray Sum Closest

题目链接：http://www.lintcode.com/en/problem/subarray-sum-closest/

Given an integer array, find a subarray with sum closest to zero. Return the indexes of the first number and last number.

Example

Given [-3, 1, 1, -3, 5], return [0, 2], [1, 3], [1, 1], [2, 2] or [0, 4].

Challenge 

O(nlogn) time

题意：获得一个数组中的一个连续的子数组，这个连续的子数组必须是这个数组的所有子数组中所有元素之和最接近0的那个，返回该子数组的开始与结束的下标

挑战：要求时间复杂度O(nlogn) ，一般就是二分或者排序，这个二分肯定不行，所以是不是要考虑一下排序。

首先，两次循环肯定没问题，但是可以发现，很多子数组的和都重复计算了，那么如何做一个缓存呢，这就是优化的点。

缓存第i项的前i项和，将其放入数组中，这就是缓存，因为所有连续的子数组的和都可以从这获得，如我想知道第n1项到第n2项这个子数组的和，那么需要将第n1-1的前n项和与第n2项的前n项和相减，即可获得。

那么，如果两个前n项和很接近，那么是不是代表着这两个n项和可以计算出来的这个子数组的和接近于0呢？思路就在这

附上代码，我把前n项和与其下标n封装了一下，封成一个新类，Data

private class Data {
		private int pos;
		private int sum;
		
		public Data(int pos, int sum) {
			this.pos = pos;
			this.sum = sum;
		}
	}
	
	public int[] subarraySumClosest(int[] nums) {
        // write your code here
        int[] rst = new int[2];
        List<Data> dataList = new ArrayList<Data>();
		int closest = Integer.MAX_VALUE;
		int sum = 0;
		
		dataList.add(new Data(-1, 0));
		for(int i = 0; i < nums.length; i++) {
			sum += nums[i];
			if(sum == 0) {
				rst[0] = 0;
				rst[1] = i;
				return rst;
			}
			dataList.add(new Data(i, sum));
		}
		
		Collections.sort(dataList, new Comparator<Data>() {
			@Override
			public int compare(Data o1, Data o2) {
				return o1.sum - o2.sum;
			}			
		});
		
		for(int i = 0; i < dataList.size()-1; i++) {
			Data d1 = dataList.get(i);
			Data d2 = dataList.get(i+1);
			int dif = Math.abs(d1.sum - d2.sum);
			if(dif < closest) {
				closest = dif;
				if(d1.pos < d2.pos) {
					rst[0] = d1.pos + 1;
					rst[1] = d2.pos;
				} else {
					rst[0] = d2.pos + 1;
					rst[1] = d1.pos;
				}
			}
		}		
		
		return rst;
    }