【每日一题Day90】LC1814统计一个数组中好对子的数目 | 哈希表

最新推荐文章于 2024-09-20 15:28:15 发布

TIkitianya

最新推荐文章于 2024-09-20 15:28:15 发布

阅读量356

点赞数 1

分类专栏：每日一题哈希表文章标签：散列表 leetcode 数据结构

本文链接：https://blog.csdn.net/Tikitian/article/details/128714089

版权

每日一题同时被 2 个专栏收录

371 篇文章 1 订阅

订阅专栏

哈希表

57 篇文章 0 订阅

订阅专栏

统计一个数组中好对子的数目【LC1814】

You are given an array nums that consists of non-negative integers. Let us define rev(x) as the reverse of the non-negative integer x. For example, rev(123) = 321, and rev(120) = 21. A pair of indices (i, j) is nice if it satisfies all of the following conditions:

0 <= i < j < nums.length
nums[i] + rev(nums[j]) == nums[j] + rev(nums[i])

Return the number of nice pairs of indices. Since that number can be too large, return it modulo 109 + 7.

思路：如果两个数满足好对子，那么这两个数反转后的变化量相同。因此可以使用哈希表存放反转后的变化量及其次数 $co u n t$ ，该变化量存在的所有好对子个数为 $co u n t * (co u n t - 1) /2$
实现
```
class Solution {
    public int countNicePairs(int[] nums) {
        int MOD = (int)(1e9 + 7);
        Map<Integer,Long> valToCount = new HashMap<>();
        for (int num : nums){
            int change = num - rev(num);
            valToCount.put(change, valToCount.getOrDefault(change, 0L) + 1);
        }
        long res = 0;
        for (long count : valToCount.keySet()){
            res = (res + count * (count - 1) / 2) % MOD;            
        }
        return (int)res;
    }
    public int rev(int num){
        int res = 0;
        while (num != 0){
            res = res * 10 + num % 10;
            num /= 10;
        }
        return res;
    }
}
```
- 复杂度
  - 时间复杂度： $O (n l o g m + n)$ ， $n$ 为数组长度，对数组中每个数求取变化量放入哈希表的时间复杂度为 $O (n l o g m)$
  - 空间复杂度： $O (n)$
优化：一次遍历，由于哈希表里保存的是以前某个变化量出现的次数，因此可以直接累加该变化量以前的出现次数 $co u n t$ ，即为以当前数 $x$ 为 $j$ ，数组中共有 $co u n t$ 个 $i$
实现
```
class Solution {
    public int countNicePairs(int[] nums) {
        int MOD = (int)(1e9 + 7);
        Map<Integer,Integer> valToCount = new HashMap<>();
        int res = 0;
        for (int num : nums){
            int change = num - rev(num);
            res = (res + valToCount.getOrDefault(change, 0)) % MOD;
            valToCount.put(change, valToCount.getOrDefault(change, 0) + 1);
        }
        return res;
    }
    public int rev(int num){
        int res = 0;
        while (num != 0){
            res = res * 10 + num % 10;
            num /= 10;
        }
        return res;
    }
}
```
- 复杂度
  - 时间复杂度： $O (n l o g m)$ ， $n$ 为数组长度， $m$ 为数组中的最大值
  - 空间复杂度： $O (n)$
- 耗费时间多于先存储后计算，猜测原因未反复累加取余耗费的时间较高。
- 空间优于先存储后计算，因为没有使用long类型变量