力扣每日一题：891. 子序列宽度之和（java）

891. 子序列宽度之和https://leetcode.cn/problems/sum-of-subsequence-widths/

目录

题目描述：

解法思路：

优化思路：

---

题目描述：

一个序列的 宽度 定义为该序列中最大元素和最小元素的差值。

给你一个整数数组 nums ，返回 nums 的所有非空 子序列 的 宽度之和 。由于答案可能非常大，请返回对 109 + 7 取余 后的结果。

子序列 定义为从一个数组里删除一些（或者不删除）元素，但不改变剩下元素的顺序得到的数组。例如，[3,6,2,7] 就是数组 [0,3,1,6,2,2,7] 的一个子序列。

示例 1：

输入：nums = [2,1,3]
输出：6
解释：子序列为 [1], [2], [3], [2,1], [2,3], [1,3], [2,1,3] 。
相应的宽度是 0, 0, 0, 1, 1, 2, 2 。
宽度之和是 6 。

示例 2：

输入：nums = [2]
输出：0

解法思路：

[2,1,3]的子序列为：[2], [1], [3], [2,1], [2,3], [1,3], [2,1,3]

宽度是：0 0 0 1 1 2 2 和为6

[1,2,3]的子序列为：[1], [2], [3], [1,2], [1,3], [2,3], [1,2,3]

宽度是：0 0 0 1 2 1 2 和为6

由此不难发现子序列宽度之和与数组的元素顺序无关，因为题目中宽度的定义是最大值-最小值，而不是索引最大值-索引最小值。

所以我们先将数组排序。

由这个例子，我们不难推出：答案6=0（2-2）+0（1-1）+0（3-3）+1（2-1）+1（3-2）+2（3-1）+2（3-1） = （1*1 - 1*4） + （2*2 - 2*2） + （3*4 - 3*1）

由这个公式，我们可以得出一个结论：最后宽度之和 就是每个元素作为最大元素和(这个元素大小*当老大次数) - 作为最小元素和（这个元素大小*做老幺次数）

那么就可以推广这个公式到n：

1*2^0 - 1*2^(n-1) + 2*2^1 - 2*2^(n-2) +...+ (n-1)*2^(n-2) - (n-1)*2^1 + n*2^(n-1) - n*2^0

（其中1是第一个元素 n是第n个元素 2...(n-1)以此类推）

下面给出这道题的具体代码：

public class Main{
    public static void main(String[] args) {
        System.out.println(sumSubseqWidths(new int[]{2,1,3}));
    }
 
    private static int sumSubseqWidths(int[] nums) {
        final int MOD = 1000000007;
        Arrays.sort(nums);
        long sum = 0L;
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            sum += (long) (nums[i] * Math.pow(2, i)) - (long) (nums[i] * Math.pow(2, n - 1 - i));
        }
        return (int) ((sum % MOD + MOD) % MOD);
    }
}

注意：公式中有减法，最后结果可能为负数，所以要先加上MOD，在对MOD取模

可惜的是，这个公式在运算数组长度较大的时候不能精确的算出结果，可能是因为

(long) (nums[i] * Math.pow(2, i)) - (long) (nums[i] * Math.pow(2, n - 1 - i)) 超过了long的范围

（Math.pow()需要的类型是double）

不过公式是正确的。

优化思路：

因为由上面的公式 可知 一个元素（第一个元素） 作为最大元素次数 与 其对称元素（最后一个元素）作为最小元素次数 相等

公式：1*2^0 - 1*2^(n-1) + 2*2^1 - 2*2^(n-2) +...+ (n-1)*2^(n-2) - (n-1)*2^1 + n*2^(n-1) - n*2^0

如上面标注出的 1的最大次数 等于 n的最小次数

那么这个公式就可以改写成：

(1-n)*2^0 + (2-(n-1))*2^1 +...+ ((n-1)-2)*2^(n-2) + (n-1)*2^(n-1)

于是就可以给出优化后的代码：

public class Main{
    public static void main(String[] args) {
        System.out.println(sumSubseqWidths(new int[]{2,1,3}));
    }

    private static int sumSubseqWidths(int[] nums) {
        final int MOD = 1000000007;
        Arrays.sort(nums);
        long sum = 0L;
        int n = nums.length;
        long pow = 1L;//2^0=1
        for (int i = 0; i < n; i++) {
            sum += (nums[i] - nums[n - 1 - i]) * pow;
            pow = pow * 2 % MOD;
        }
        return (int) ((sum % MOD + MOD) % MOD);
    }
}

每次求和 和 相乘的次数（2的几次方）都对MOD取模了，所以不用担心会超过数据范围

要注意的是 子序列为单个元素时 两种计算公式都额外当成了 作为最大元素与最小元素各一次 但都减去了 所以对结果无影响