Hard

题目描述

序列的宽度是指序列中最大元素和最小元素之间的差值。

给你一个整数数组 nums ，返回 nums 的所有非空子序列的宽度之和。由于答案可能非常大，请返回对 10^9 + 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 <= 10^5
  • 1 <= nums[i] <= 10^5

解题思路

这道题要求计算所有子序列的宽度之和，直接枚举所有子序列的时间复杂度是指数级的，需要寻找数学规律。

核心思路： 首先对数组排序。排序后，对于任意子序列，最小值必然是其中位置最靠左的元素，最大值是位置最靠右的元素。

考虑排序后数组中的元素 nums[i]：

  • 当 nums[i] 作为子序列最大值时：子序列必须包含 nums[i]，且不能包含 nums[i] 右边的任何元素，但可以包含左边的任意元素组合，共有 2^i 种子序列
  • 当 nums[i] 作为子序列最小值时：子序列必须包含 nums[i]，且不能包含 nums[i] 左边的任何元素，但可以包含右边的任意元素组合，共有 2^(n-1-i) 种子序列

因此，nums[i] 对答案的贡献为：nums[i] * (2^i - 2^(n-1-i))

所有元素贡献之和就是最终答案。

时间优化： 可以预计算 2 的幂次，避免重复计算。

代码实现

class Solution {
public:
    int sumSubseqWidths(vector<int>& nums) {
        const int MOD = 1e9 + 7;
        int n = nums.size();
        
        sort(nums.begin(), nums.end());
        
        vector<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++) {
            long long contribution = ((long long)nums[i] * (pow2[i] - pow2[n-1-i] + MOD)) % MOD;
            result = (result + contribution) % MOD;
        }
        
        return result;
    }
};

class Solution:
    def sumSubseqWidths(self, nums: List[int]) -> int:
        MOD = 10**9 + 7
        n = len(nums)
        nums.sort()
        
        # 预计算2的幂次
        pow2 = [1] * n
        for i in range(1, n):
            pow2[i] = (pow2[i-1] * 2) % MOD
        
        result = 0
        for i in range(n):
            contribution = nums[i] * (pow2[i] - pow2[n-1-i])
            result = (result + contribution) % MOD
        
        return result

public class Solution {
    public int SumSubseqWidths(int[] nums) {
        const int MOD = 1000000007;
        int n = nums.Length;
        
        Array.Sort(nums);
        
        long[] pow2 = new long[n];
        pow2[0] = 1;
        for (int i = 1; i < n; i++) {
            pow2[i] = (pow2[i-1] * 2) % MOD;
        }
        
        long result = 0;
        for (int i = 0; i < n; i++) {
            long contribution = ((long)nums[i] * (pow2[i] - pow2[n-1-i] + MOD)) % MOD;
            result = (result + contribution) % MOD;
        }
        
        return (int)result;
    }
}

var sumSubseqWidths = function(nums) {
    const MOD = 1e9 + 7;
    const n = nums.length;
    
    nums.sort((a, b) => a - b);
    
    const pow2 = new Array(n);
    pow2[0] = 1;
    for (let i = 1; i < n; i++) {
        pow2[i] = (pow2[i-1] * 2) % MOD;
    }
    
    let result = 0;
    for (let i = 0; i < n; i++) {
        const contribution = (nums[i] * (pow2[i] - pow2[n-1-i] + MOD)) % MOD;
        result = (result + contribution) % MOD;
    }
    
    return result;
};
在 LeetCode 上运行： 力扣中文版 LeetCode 国际版

复杂度分析

复杂度类型值
时间复杂度O(n log n)
空间复杂度O(n)

其中 n 是数组长度。时间复杂度主要来自排序操作，空间复杂度来自存储 2 的幂次数组。