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

给你一个下标从 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

Related Topics

  • 数组
  • 哈希表

题目链接: link

解答

本题的难度是 Easy.

这个题目第一直觉就是记录两个数组, 一个前缀元素种类, 一个后缀元素种类, 那么又要不同的元素, 不同元素第一反应就是集合, 因此我们可以把每一个元素都放到 HashSet 里, 然后记录 HashSet 的 size.

代码如下:

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

击败 88.71%, 用时 4ms, 然后发现可以不需要 tail 数组, 直接减就好, 还少一次for循环, 但是时间效率不变, 因此怀疑是因为 HashSet 导致的时间效率区别, 又 nums[i] 的范围是确定的, 因此可以用数组存所有可能.

代码如下:

class Solution {
    public int[] distinctDifferenceArray(int[] nums) {
        // 这里 51 是因为懒得后面-1
        boolean[] hashSet = new boolean[51];
        int size = 0;
        int n = nums.length;
        int[] pre = new int[n];
        for (int i = 0; i < n; i++) {
            if (!hashSet[nums[i]]){
                hashSet[nums[i]] = true;
                size++;
            }
            pre[i] = size;
        }
        size = 0;
        hashSet = new boolean[51];
        for (int i = n - 1; i > 0; i--) {
            if (!hashSet[nums[i]]){
                hashSet[nums[i]] = true;
                size++;
            }
            pre[i-1] -=  size;
        }
        return pre;
    }
}

猜测是成功的, 换成了数组存就可以将时间效率提高到 2ms, 并且击败 100%.