LFU缓存机制

https://leetcode-cn.com/problems/lfu-cache/
请你为 最不经常使用（LFU）缓存算法设计并实现数据结构。

实现 LFUCache 类：

LFUCache(int capacity) - 用数据结构的容量 capacity 初始化对象
int get(int key) - 如果键存在于缓存中，则获取键的值，否则返回 -1。
void put(int key, int value) - 如果键已存在，则变更其值；如果键不存在，请插入键值对。当缓存达到其容量时，则应该在插入新项之前，使最不经常使用的项无效。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，应该去除 最久未使用 的键。
注意「项的使用次数」就是自插入该项以来对其调用 get 和 put 函数的次数之和。使用次数会在对应项被移除后置为 0 。

为了确定最不常使用的键，可以为缓存中的每个键维护一个 使用计数器 。使用计数最小的键是最久未使用的键。

当一个键首次插入到缓存中时，它的使用计数器被设置为 1 (由于 put 操作)。对缓存中的键执行 get 或 put 操作，使用计数器的值将会递增。

class LFUCache {
public:
    LFUCache(int capacity) {
        cap = capacity;
        minCount = 0;
        LFUMap.clear();
        LFUCount.clear();
        CountMap.clear();
    }
    
    int get(int key) {
        if (LFUMap.find(key) == LFUMap.end())
            return -1;
        else {
            // 如果key对应的count与目前最小的count一样大,则需要判断minCount是否需要增加
            if (LFUCount[key] == minCount && CountMap[minCount].size() == 1) {
                ++minCount;
            } 
            pair<int, int> _pair = make_pair(key, LFUMap[key]->second);
            CountMap[LFUCount[key]].erase(LFUMap[key]);
            LFUCount[key] += 1;
            // if (CountMap.find(LFUCount[key]) == CountMap.end()) {
            //     list<pair<int, int>> l;
            //     CountMap[LFUCount[key]] = l;
            // }
            CountMap[LFUCount[key]].push_back(_pair);
            auto __end = CountMap[LFUCount[key]].end();
            LFUMap[key] = --__end;
            return LFUMap[key]->second;
        }
    }
    
    void put(int key, int value) {
        if (cap == 0) return;
        // 新的key
        if (LFUMap.find(key) == LFUMap.end()) {
            if (LFUMap.size() == cap) {
                // 如果满了清除最旧最少使用的结点
                auto iter = CountMap[minCount].begin();
                LFUMap.erase(iter->first);
                LFUCount.erase(iter->first);
                CountMap[minCount].pop_front();
            }
            // 插入新的结点
            pair<int, int> _pair = make_pair(key, value);
            minCount = 1;
            LFUCount[key] = 1;
            CountMap[1].push_back(_pair);
            // LFUMap[key] = CountMap[1].end();
            auto __end = CountMap[1].end();
            LFUMap[key] = --__end;
        } else {
            // 如果key对应的count与目前最小的count一样大,则需要判断minCount是否需要增加
            if (LFUCount[key] == minCount && CountMap[minCount].size() == 1) {
                ++minCount;
            } 
            pair<int, int> _pair = make_pair(key, value);
            CountMap[LFUCount[key]].erase(LFUMap[key]);
            LFUCount[key] += 1;
            CountMap[LFUCount[key]].push_back(_pair);
            auto __end = CountMap[LFUCount[key]].end();
            LFUMap[key] = --__end;
        }
        
    }
    
    unordered_map<int, list<pair<int, int>>::iterator> LFUMap; // key node<key,value>::iter
    unordered_map<int, int> LFUCount; // key,count
    unordered_map<int, list<pair<int, int>>> CountMap; // count, node list
    int minCount;
    int cap;
};

/**
 * Your LFUCache object will be instantiated and called as such:
 * LFUCache* obj = new LFUCache(capacity);
 * int param_1 = obj->get(key);
 * obj->put(key,value);
 */