1755. 最接近目标值的子序列和

每日一题 leetCode，今天分享 leetCode1755题，算法借鉴—左神！

题目：

给你一个整数数组 nums 和一个目标值 goal 。

你需要从 nums 中选出一个子序列，使子序列元素总和最接近 goal 。也就是说，如果子序列元素和为 sum ，你需要 最小化绝对差 abs(sum - goal) 。

返回 abs(sum - goal) 可能的 最小值 。

注意，数组的子序列是通过移除原始数组中的某些元素（可能全部或无）而形成的数组。

示例 1：

输入：nums = [5,-7,3,5], goal = 6
输出：0
解释：选择整个数组作为选出的子序列，元素和为 6 。
子序列和与目标值相等，所以绝对差为 0 。
示例 2：

输入：nums = [7,-9,15,-2], goal = -5
输出：1
解释：选出子序列 [7,-9,-2] ，元素和为 -4 。
绝对差为 abs(-4 - (-5)) = abs(1) = 1 ，是可能的最小值。
示例 3：

输入：nums = [1,2,3], goal = -7
输出：7
 

提示：

1 <= nums.length <= 40
-10^7 <= nums[i] <= 10^7
-10^9 <= goal <= 10^9

        本题属于 hard 难度，给的数据是-10^7 <= nums[i] <= 10^7 -10^9 <= goal <= 10^9，这就说明，时间复杂度如果是大于 O（N），一定会超时，所以，如果看成0 1 背包问题，肯定过不了！还有一个条件是1 <= nums.length <= 40，这个条件干啥的？提示了啥？——数组长度很短，只有40个大小，如果0 1 暴力去做，时间复杂度是 O(2^40) > O(10^8)，肯定也超时了！所以，好办法是一分为二，两遍各是20大小长度，算两次，两个数组再排序，根据有序性遍历，时间复杂度最多是 O(2^20 * lg 2^20) = O(20 * 2^20)，一定不超时！

        笔者一上来就用 0 1 背包问题求解，结果证明不行，虽然想到40长度可以利用，但是，没想到一分为二，想到的是二分之后合并，显然是复杂了很多。

        那么，核心代码有两块：① 暴力递归 ② 排序后遍历

（一）暴力递归

/**
 * 
 * @param index：index 位置之前已经选择，只需要选择 index 以及之后
 * @param end：终止位置
 * @param count：数组下标
 * @param sum：当前总和
 * @param nums：数组
 * @param arr：新的数组
 * @return：数组下标
 */

public static int process(int index, int end, int count, int sum, int[] nums, int[] arr) {
    // 递归出口
    if (index == end) {
        arr[count] = sum;
        count++;
        return count;
    }
    // 继续递归
    // 1.要这个数字
    count = process(index + 1, end, count, sum + nums[index], nums, arr);
    // 2.不要这个数字
    count = process(index + 1, end, count, sum, nums, arr);

    return count;
}

另外：返回数组下标，这个点一开始卡了笔者挺久。

（二）排序后遍历

public static int minAbsDifference(int[] nums, int goal) {
    if (nums == null || nums.length == 0) {
        return goal;
    }

    int len = (int) Math.pow(2, nums.length / 2 + 1);

    int[] leftArr = new int[len];
    int[] rightArr = new int[len];

    // 计算和
    int leftCount = process(0, nums.length / 2, 0, 0, nums, leftArr);
    int rightCount = process(nums.length / 2, nums.length, 0, 0, nums, rightArr);

    // 整合
    Arrays.sort(leftArr, 0, leftCount);
    Arrays.sort(rightArr, 0, rightCount);

    int ans = Math.abs(goal);
    int rightIndex = rightCount - 1;

    for (int i = 0; i < leftCount; i++) {
        int rest = goal - leftArr[i];
        while (rightIndex > 0 && Math.abs(rest - rightArr[rightIndex]) >= Math.abs(rest - rightArr[rightIndex - 1])) {
            rightIndex--;
        }
        ans = Math.min(ans, Math.abs(rest - rightArr[rightIndex]));
    }

    return ans;
}

（三）全部代码

public static int minAbsDifference(int[] nums, int goal) {
    if (nums == null || nums.length == 0) {
        return goal;
    }

    int len = (int) Math.pow(2, nums.length / 2 + 1);

    int[] leftArr = new int[len];
    int[] rightArr = new int[len];

    // 计算和
    int leftCount = process(0, nums.length / 2, 0, 0, nums, leftArr);
    int rightCount = process(nums.length / 2, nums.length, 0, 0, nums, rightArr);

    // 整合
    Arrays.sort(leftArr, 0, leftCount);
    Arrays.sort(rightArr, 0, rightCount);

    int ans = Math.abs(goal);
    int rightIndex = rightCount - 1;

    for (int i = 0; i < leftCount; i++) {
        int rest = goal - leftArr[i];
        while (rightIndex > 0 && Math.abs(rest - rightArr[rightIndex]) >= Math.abs(rest - rightArr[rightIndex - 1])) {
            rightIndex--;
        }
        ans = Math.min(ans, Math.abs(rest - rightArr[rightIndex]));
    }

    return ans;
}

/**
 *
 * @param index：index 位置之前已经选择，只需要选择 index 以及之后
 * @param end：终止位置
 * @param count：数组下标
 * @param sum：当前总和
 * @param nums：数组
 * @param arr：新的数组
 * @return：数组下标
 */
public static int process(int index, int end, int count, int sum, int[] nums, int[] arr) {
    // 递归出口
    if (index == end) {
        arr[count] = sum;
        count++;
        return count;
    }
    // 继续递归
    // 1.要这个数字
    count = process(index + 1, end, count, sum + nums[index], nums, arr);
    // 2.不要这个数字
    count = process(index + 1, end, count, sum, nums, arr);

    return count;
}

总结：本题难度在于需要根据数组长度进行分治，想到这个点，问题就解决了！