[算法题] 最接近零的子数组和 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.

样例
给出[-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;    }}//中间注释掉的代码是粗暴解法的代码

如果读者对以上有不解或者发现有错的地方请给我留言。更多精彩编程，算法方面的知识请关注我的公众号love_coding，可扫描二维码直接关注

纯手打，如需转载请注明出处哦。