算法-双Hash表-2671. 频率跟踪器

2671. 频率跟踪器

说明

请你设计并实现一个能够对其中的值进行跟踪的数据结构，并支持对频率相关查询进行应答。

实现 FrequencyTracker 类：

FrequencyTracker()：使用一个空数组初始化 FrequencyTracker 对象。
void add(int number)：添加一个 number 到数据结构中。
void deleteOne(int number)：从数据结构中删除一个 number 。数据结构 可能不包含 number ，在这种情况下不删除任何内容。
bool hasFrequency(int frequency): 如果数据结构中存在出现 frequency 次的数字，则返回 true，否则返回 false。
 

示例 1：

输入
["FrequencyTracker", "add", "add", "hasFrequency"]
[[], [3], [3], [2]]
输出
[null, null, null, true]

解释
FrequencyTracker frequencyTracker = new FrequencyTracker();
frequencyTracker.add(3); // 数据结构现在包含 [3]
frequencyTracker.add(3); // 数据结构现在包含 [3, 3]
frequencyTracker.hasFrequency(2); // 返回 true ，因为 3 出现 2 次
示例 2：

输入
["FrequencyTracker", "add", "deleteOne", "hasFrequency"]
[[], [1], [1], [1]]
输出
[null, null, null, false]

解释
FrequencyTracker frequencyTracker = new FrequencyTracker();
frequencyTracker.add(1); // 数据结构现在包含 [1]
frequencyTracker.deleteOne(1); // 数据结构现在为空 []
frequencyTracker.hasFrequency(1); // 返回 false ，因为数据结构为空
示例 3：

输入
["FrequencyTracker", "hasFrequency", "add", "hasFrequency"]
[[], [2], [3], [1]]
输出
[null, false, null, true]

解释
FrequencyTracker frequencyTracker = new FrequencyTracker();
frequencyTracker.hasFrequency(2); // 返回 false ，因为数据结构为空
frequencyTracker.add(3); // 数据结构现在包含 [3]
frequencyTracker.hasFrequency(1); // 返回 true ，因为 3 出现 1 次
 

提示：

1 <= number <= 105
1 <= frequency <= 105
最多调用 add、deleteOne 和 hasFrequency 共计 2 * 105 次

题解思路

双Hash表

• 一开始看到这个题目的时候。想得就。
  • 一个Map，key为num，value为出现的次数
  • 然后往里面塞就完事了，最后遍历这个Map的value，看看有没有匹配的。
  • 这个hasFrequency()的复杂度是O(m*n)（m是不同元素的个数。n是调用hasFrequency的次数）。。不知道能不能过。(经过尝试。过不了)
• 然后迭代思路。把次数也维护一个Map不就完事了
  • 新添加的Map，key为出现的次数，value为出现此次数num的数量
  • 每次更新的时候，先更新这个新的frequencyMap，再更新原来key为num，value为出现的次数的Map
  • 这样复杂度就是O(1)的了

Code

双Hash表

class FrequencyTracker {

    // key为num，value为出现的次数
    private Map<Integer, Integer> keyMap = new HashMap<>();
    // key为出现的次数，value为出现此次数num的数量
    private Map<Integer, Integer> frequencyMap = new HashMap<>();

    public FrequencyTracker() {

    }

    // 当发生更新时，总是要做的操作，封装起来
    private void update(int number, int op){
        // 获取当前数出现的次数
        int c = keyMap.getOrDefault(number, 0);
        // 数量有改变，当前的频率的map肯定需要先减一
        frequencyMap.put(c, frequencyMap.getOrDefault(c, 0) - 1);
        // 根据操作类型，number出现的次数加一或减一
        keyMap.put(number, c + op);
        // 将频率反馈到频率map
        frequencyMap.put(c + op, frequencyMap.getOrDefault(c + op, 0) + 1);
    }
    
    public void add(int number) {
        update(number, +1);
    }
    
    public void deleteOne(int number) {
        if(keyMap.containsKey(number) && keyMap.get(number) != 0){
            update(number, -1);
        }
    }
    
    public boolean hasFrequency(int frequency) {
        return frequencyMap.getOrDefault(frequency, 0) > 0;
    }
}

/**
 * Your FrequencyTracker object will be instantiated and called as such:
 * FrequencyTracker obj = new FrequencyTracker();
 * obj.add(number);
 * obj.deleteOne(number);
 * boolean param_3 = obj.hasFrequency(frequency);
 */