题目：

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

给你一个整数数组 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

提示：

1 <= nums.length <= 105
1 <= nums[i] <= 105

解题思路：

由于求的时子序列的宽度，不是子数组的宽度。而宽度的要素是序列中最大值和最小值，顺序对于最大值和最小值不影响。我们对数组进行排序(递增)

计算每个元素作为最大值能有多少种子序列，经过计算得到结论如下：

  1. nums[i]作为最大值时，它有 2 ^ i 个子序列，而作为最小值时它有 2 ^ n - 1 - i 个元素
  2. 每个元素对总宽度和贡献为(2 ^ i - 2 ^ (n-1-i)) * nums[i]
  • 这里要特别注意，为什么要(2 ^ i - 2 ^ (n-1-i))，因为nums[i]的最大值子序列会覆盖前面的最小值子序列。

代码：

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution:
    def sumSubseqWidths(self, nums: List[int]) -> int:
        MOD = 10 ** 9 + 7
        n = len(nums)
        p = [0] * n
        p[0] = 1
        nums.sort()
        for i in range(1, n):
            p[i] = p[i - 1] * 2 % MOD

        result = 0
        for i, x in enumerate(nums):
            result += (p[i] - p[n - 1 - i]) * x
        return result % MOD

C++

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution {
public:
    int sumSubseqWidths(vector<int>& nums) {
        const long long MOD = 1000000000 + 7;
        sort(nums.begin(), nums.end());
        int n = nums.size();
        long long pow2[n];
        pow2[0] = 1;

        // 求子序列
        for (int i = 1; i < n; ++i) {
            pow2[i] = pow2[i - 1] * 2 % MOD;
        }
        long long result = 0;
        for (int i = 0; i < n; ++i) {
            result += (pow2[i] - pow2[n - 1 - i]) * nums[i];
        }
        // 有result有可能是负数
        return (result % MOD + MOD) % MOD;
    }
};