Easy

题目描述

给你一个长度为 n 的下标从 0 开始的数组 nums。

nums 的 不同差值数组 是一个长度为 n 的数组 diff，其中 diff[i] 等于前缀 nums[0, ..., i] 中不同元素的数目 减去 后缀 nums[i + 1, ..., n - 1] 中不同元素的数目。

返回 nums 的 不同差值数组。

注意 nums[i, ..., j] 表示 nums 的一个从下标 i 开始到下标 j 结束的子数组（包含下标 i 和 j 对应元素）。特别地，如果 i > j ，则 nums[i, ..., j] 表示一个空子数组。

示例 1：

输入：nums = [1,2,3,4,5]
输出：[-3,-1,1,3,5]
解释：对于 i = 0，前缀中有 1 个元素，后缀中有 4 个不同元素。因此，diff[0] = 1 - 4 = -3。
对于 i = 1，前缀中有 2 个不同元素，后缀中有 3 个不同元素。因此，diff[1] = 2 - 3 = -1。
对于 i = 2，前缀中有 3 个不同元素，后缀中有 2 个不同元素。因此，diff[2] = 3 - 2 = 1。
对于 i = 3，前缀中有 4 个不同元素，后缀中有 1 个不同元素。因此，diff[3] = 4 - 1 = 3。
对于 i = 4，前缀中有 5 个不同元素，后缀中没有元素。因此，diff[4] = 5 - 0 = 5。

示例 2：

输入：nums = [3,2,3,4,2]
输出：[-2,-1,0,2,3]
解释：对于 i = 0，前缀中有 1 个元素，后缀中有 3 个不同元素。因此，diff[0] = 1 - 3 = -2。
对于 i = 1，前缀中有 2 个不同元素，后缀中有 3 个不同元素。因此，diff[1] = 2 - 3 = -1。
对于 i = 2，前缀中有 2 个不同元素，后缀中有 2 个不同元素。因此，diff[2] = 2 - 2 = 0。
对于 i = 3，前缀中有 3 个不同元素，后缀中有 1 个不同元素。因此，diff[3] = 3 - 1 = 2。
对于 i = 4，前缀中有 3 个不同元素，后缀中没有元素。因此，diff[4] = 3 - 0 = 3。

提示：

  • 1 <= n == nums.length <= 50
  • 1 <= nums[i] <= 50

解题思路

解题思路

这道题需要计算每个位置i处，前缀nums[0...i]中不同元素的数量减去后缀nums[i+1...n-1]中不同元素的数量。

方法1：直接模拟（推荐）

对于每个位置i，分别使用集合统计前缀和后缀中的不同元素数量：

  1. 遍历数组中每个位置i
  2. 使用集合统计前缀nums[0...i]中的不同元素数量
  3. 使用集合统计后缀nums[i+1...n-1]中的不同元素数量
  4. 计算差值并存入结果数组

方法2：预处理优化

可以预先计算出每个位置的前缀不同元素数量和后缀不同元素数量：

  1. 从左到右遍历，计算每个位置的前缀不同元素数量
  2. 从右到左遍历，计算每个位置的后缀不同元素数量
  3. 最后计算差值

由于数据规模较小（n ≤ 50），直接模拟的方法足够高效且更容易理解，因此推荐使用方法1。

代码实现

class Solution {
public:
    vector<int> distinctDifferenceArray(vector<int>& nums) {
        int n = nums.size();
        vector<int> result(n);
        
        for (int i = 0; i < n; i++) {
            // 统计前缀 [0, i] 中不同元素数量
            unordered_set<int> prefixSet;
            for (int j = 0; j <= i; j++) {
                prefixSet.insert(nums[j]);
            }
            
            // 统计后缀 [i+1, n-1] 中不同元素数量
            unordered_set<int> suffixSet;
            for (int j = i + 1; j < n; j++) {
                suffixSet.insert(nums[j]);
            }
            
            result[i] = prefixSet.size() - suffixSet.size();
        }
        
        return result;
    }
};

class Solution:
    def distinctDifferenceArray(self, nums: List[int]) -> List[int]:
        n = len(nums)
        result = []
        
        for i in range(n):
            # 统计前缀 [0, i] 中不同元素数量
            prefix_set = set(nums[0:i+1])
            
            # 统计后缀 [i+1, n-1] 中不同元素数量
            suffix_set = set(nums[i+1:n])
            
            result.append(len(prefix_set) - len(suffix_set))
        
        return result

public class Solution {
    public int[] DistinctDifferenceArray(int[] nums) {
        int n = nums.Length;
        int[] result = new int[n];
        
        for (int i = 0; i < n; i++) {
            // 统计前缀 [0, i] 中不同元素数量
            HashSet<int> prefixSet = new HashSet<int>();
            for (int j = 0; j <= i; j++) {
                prefixSet.Add(nums[j]);
            }
            
            // 统计后缀 [i+1, n-1] 中不同元素数量
            HashSet<int> suffixSet = new HashSet<int>();
            for (int j = i + 1; j < n; j++) {
                suffixSet.Add(nums[j]);
            }
            
            result[i] = prefixSet.Count - suffixSet.Count;
        }
        
        return result;
    }
}

var distinctDifferenceArray = function(nums) {
    const n = nums.length;
    const result = [];
    
    for (let i = 0; i < n; i++) {
        // 统计前缀 [0, i] 中不同元素数量
        const prefixSet = new Set();
        for (let j = 0; j <= i; j++) {
            prefixSet.add(nums[j]);
        }
        
        // 统计后缀 [i+1, n-1] 中不同元素数量
        const suffixSet = new Set();
        for (let j = i + 1; j < n; j++) {
            suffixSet.add(nums[j]);
        }
        
        result.push(prefixSet.size - suffixSet.size);
    }
    
    return result;
};
在 LeetCode 上运行： 力扣中文版 LeetCode 国际版

复杂度分析

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

其中 n 是数组长度。对于每个位置，我们需要遍历前缀和后缀来统计不同元素数量，因此时间复杂度为 O(n²)。空间复杂度主要用于存储集合和结果数组。

相关题目