[算法题] 最接近零的子数组和 Subarray Sum Closest

本文链接：https://blog.youkuaiyun.com/SuperStonne/article/details/51225386

给定一个整数数组，找到一个和最接近于零的子数组。返回第一个和最有一个指数。你的代码应该返回满足要求的子数组的起始位置和结束位置
Given an integer array, find a subarray with sum closest to zero. Return the indexes of the first number and last number.

样例
给出[-3, 1, 1, -3, 5]，返回[0, 2]，[1, 3]， [1, 1]， [2, 2] 或者 [0, 4]。

这是一道和数据相关的的题目，所以我们可以很容易的想到遍历去解决。

粗暴解法：

我们要求出最接近于0的子数组，那么数组中的任何一个元素都有可能成为这个子数组的起点，那么我们可以使用双重for循环求出以每个元素为开头的最接近0的子数组。

示例代码

int closest = Integer.MAX_VALUE;
int sum;
int[] results = null;
for (int i = 0; i < nums.length; i++){
    sum = nums[i];
    if (Math.abs(sum) < closest){
        closest = Math.abs(sum);
        results = new int[]{i, i};
    }
    for (int j = i + 1; j < nums.length; j++){
        sum += nums[j];
        if (Math.abs(sum) < closest){
            closest = Math.abs(sum);
            results = new int[]{i, j};
        }
    }
}

带入数据验证结果
以每个元素开头的最接近0的子序列如下
元素1 ： -3 【-3, 1， 1】或者【-3, 1，1，-3,5】 sum = -1
元素2 : 1 【1】 sum = 1
元素3 ： 1 【1】 sum = 1
元素4 ：-3 【-3， 5】 sum = -2
元素5 ： 5 【5】 sum = 5
由此可以得出最小子序列的候选结果是以元素1,2,3开头的子序列。
该算法的复杂度为O(n*n)，但不是最优解。

精巧算法

我们创建一个数据类型，该类记录了前N项的sum和N的值，类型定义如下：

class NSum{
int sum;
int index;
public NSum(int index, int sum){
    this.sum = sum;
    this.index = index;
}
}

经过一次for循环我们将得到的NSum存入一个数组：
【0（0），-3（1），-2（2），-1（3），-4（4）, 1（5）】
接下来我们将这个新的数组进行排序，由于新数组元素是NSum的实例，我们需要使用Arrays.sort()工具方法对其排序，同时要传入自己实现的comparator，排序后结果如下：
【-4（4），-3（1），-2（2），-1（3），0（0）, 1（5）】
接下来我们再次迭代，数组中的每个元素减去前一个元素，获取最小的差值组合。我们可以得出
-3（1）减去 -4（4）为1，即为我们要找的最接近0的子序列。然后计算下标为1到3。
该算法的时间复杂度为O（nlogn）即为Arrays.sort排序的复杂度
此处看不懂的同学可参考图解

示例代码：

NSum[] nSums= new NSum[nums.length + 1];
 nSums[0] = new NSum(0, 0);
 int preSum = 0;
 for (int i = 1; i < nSums.length; i++){
     nSums[i] = new NSum(i, preSum + nums[i - 1]);
     preSum = nSums[i].sum;
 }
 int closest = Integer.MAX_VALUE;
 Arrays.sort(nSums, new Comparator<NSum>() {
     public int compare(NSum a, NSum b){
         return a.sum - b.sum;
     }
 });
 int[] result = new int[2];
 for (int i = 1; i < nSums.length; i++){
     if (closest > (nSums[i].sum - nSums[i - 1].sum)){
         closest = nSums[i].sum - nSums[i - 1].sum;
         int[] temp = new int[]{nSums[i].index - 1, nSums[i - 1].index - 1};
         Arrays.sort(temp);
         result[0] = temp[0] + 1;
         result[1] = temp[1];
     }
 }

完整代码

public class Solution {
    class NSum{
        int sum;
        int index;
        public NSum(int index, int sum){
            this.sum = sum;
            this.index = index;
        }
    }
    /**
     * @param nums: A list of integers
     * @return: A list of integers includes the index of the first number 
     *          and the index of the last number
     */
    public int[] subarraySumClosest(int[] nums) {
        if (nums == null || nums.length < 2){
            return new int[]{0, 0};
        }
        /*int closest = Integer.MAX_VALUE;
        int sum;
        int[] results = null;
        for (int i = 0; i < nums.length; i++){
            sum = nums[i];
            if (Math.abs(sum) < closest){
                closest = Math.abs(sum);
                results = new int[]{i, i};
            }
            for (int j = i + 1; j < nums.length; j++){
                sum += nums[j];
                if (Math.abs(sum) < closest){
                    closest = Math.abs(sum);
                    results = new int[]{i, j};
                }
            }
        }
        return results;*/
        NSum[] nSums= new NSum[nums.length + 1];
        nSums[0] = new NSum(0, 0);
        int preSum = 0;
        for (int i = 1; i < nSums.length; i++){
            nSums[i] = new NSum(i, preSum + nums[i - 1]);
            preSum = nSums[i].sum;
        }
        int closest = Integer.MAX_VALUE;
        Arrays.sort(nSums, new Comparator<NSum>() {
            public int compare(NSum a, NSum b){
                return a.sum - b.sum;
            }
        });
        int[] result = new int[2];
        for (int i = 1; i < nSums.length; i++){
            if (closest > (nSums[i].sum - nSums[i - 1].sum)){
                closest = nSums[i].sum - nSums[i - 1].sum;
                int[] temp = new int[]{nSums[i].index - 1, nSums[i - 1].index - 1};
                Arrays.sort(temp);
                result[0] = temp[0] + 1;
                result[1] = temp[1];
            }
        }
        return result;
    }
}
//中间注释掉的代码是粗暴解法的代码