Question

2670. 找出不同元素数目差数组

English Version

题目描述

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

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 个不同的元素，而在后缀中有 0 个不同的元素。因此，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 个不同的元素，而在后缀中有 0 个不同的元素。因此，diff[4] = 3 - 0 = 3 。 

 

提示：

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

解法

方法一：哈希表 + 预处理后缀

我们可以预处理出一个后缀数组 $suf$，其中 $suf[i]$ 表示后缀 $nums[i, …, n - 1]$ 中不同元素的数目，在预处理过程中，我们使用一个哈希表 $s$ 来维护后缀中出现过的元素，这样我们就可以在 $O(1)$ 的时间内查询后缀中不同元素的数目。

预处理完后缀数组 $suf$ 后，我们清空哈希表 $s$，然后再次遍历数组 $nums$，用哈希表 $s$ 来维护前缀中出现过的元素，那么位置 $i$ 的答案就是 $s$ 中不同元素的数目减去 $suf[i + 1]$，即 $|s| - suf[i + 1]$。

时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是数组 $nums$ 的长度。

class Solution:
  def distinctDifferenceArray(self, nums: List[int]) -> List[int]:
    n = len(nums)
    suf = [0] * (n + 1)
    s = set()
    for i in range(n - 1, -1, -1):
      s.add(nums[i])
      suf[i] = len(s)
    s.clear()
    ans = [0] * n
    for i, x in enumerate(nums):
      s.add(x)
      ans[i] = len(s) - suf[i + 1]
    return ans

class Solution {
  public int[] distinctDifferenceArray(int[] nums) {
    int n = nums.length;
    int[] suf = new int[n + 1];
    Set<Integer> s = new HashSet<>();
    for (int i = n - 1; i >= 0; --i) {
      s.add(nums[i]);
      suf[i] = s.size();
    }
    s.clear();
    int[] ans = new int[n];
    for (int i = 0; i < n; ++i) {
      s.add(nums[i]);
      ans[i] = s.size() - suf[i + 1];
    }
    return ans;
  }
}

class Solution {
public:
  vector<int> distinctDifferenceArray(vector<int>& nums) {
    int n = nums.size();
    vector<int> suf(n + 1);
    unordered_set<int> s;
    for (int i = n - 1; i >= 0; --i) {
      s.insert(nums[i]);
      suf[i] = s.size();
    }
    s.clear();
    vector<int> ans(n);
    for (int i = 0; i < n; ++i) {
      s.insert(nums[i]);
      ans[i] = s.size() - suf[i + 1];
    }
    return ans;
  }
};

func distinctDifferenceArray(nums []int) []int {
  n := len(nums)
  suf := make([]int, n+1)
  s := map[int]bool{}
  for i := n - 1; i >= 0; i-- {
    s[nums[i]] = true
    suf[i] = len(s)
  }
  ans := make([]int, n)
  s = map[int]bool{}
  for i, x := range nums {
    s[x] = true
    ans[i] = len(s) - suf[i+1]
  }
  return ans
}

function distinctDifferenceArray(nums: number[]): number[] {
  const n = nums.length;
  const suf: number[] = Array(n + 1).fill(0);
  const s: Set<number> = new Set();
  for (let i = n - 1; i >= 0; --i) {
    s.add(nums[i]);
    suf[i] = s.size;
  }
  s.clear();
  const ans: number[] = Array(n).fill(0);
  for (let i = 0; i < n; ++i) {
    s.add(nums[i]);
    ans[i] = s.size - suf[i + 1];
  }
  return ans;
}

use std::collections::HashSet;

impl Solution {
  pub fn distinct_difference_array(nums: Vec<i32>) -> Vec<i32> {
    let n = nums.len();
    let mut suf = vec![0; n + 1];
    let mut s = HashSet::new();

    for i in (0..n).rev() {
      s.insert(nums[i]);
      suf[i] = s.len();
    }

    let mut ans = Vec::new();
    s.clear();
    for i in 0..n {
      s.insert(nums[i]);
      ans.push((s.len() - suf[i + 1]) as i32);
    }

    ans
  }
}