LeetCode 460. LFU Cache LFU缓存 (C++/Java)

题目：

Design and implement a data structure for Least Frequently Used (LFU)cache. It should support the following operations: get and put.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
put(key, value) - Set or insert the value if the key is not already present. When the cache reaches its capacity, it should invalidate the least frequently used item before inserting a new item. For the purpose of this problem, when there is a tie (i.e., two or more keys that have the same frequency), the least recently used key would be evicted.

Note that the number of times an item is used is the number of calls to the get and put functions for that item since it was inserted. This number is set to zero when the item is removed.

 

Follow up:
Could you do both operations in O(1) time complexity?

 

Example:

LFUCache cache = new LFUCache( 2 /* capacity */ );

cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // returns 1
cache.put(3, 3);    // evicts key 2
cache.get(2);       // returns -1 (not found)
cache.get(3);       // returns 3.
cache.put(4, 4);    // evicts key 1.
cache.get(1);       // returns -1 (not found)
cache.get(3);       // returns 3
cache.get(4);       // returns 4

分析：

设计并实现最不经常使用（LFU）缓存的数据结构。相比LRU，LFU增加了频率这一概念，在cache满了的时候，将会把最不经常使用的缓存清除掉，在本题则是以访问频率体现的。

利用hashmap来记录当前数据{key, value}和其出现次数之间的映射，我们可以把出现频率相同的key都放到一个list集合中，再使用一个hashmap建立频率和list之间的映射。为了能够在O(1)的时间内完成操作了，要快速的定位list中key的位置，我们再用一个hashmap来建立key和freq中key的位置之间的映射。最后当然我们还需要两个变量cap和minFreq，分别来保存cache的大小，和当前最小的频率。

我们假设容量为2，先put(1, 1)和put(2, 2)，此时容器的存储情况如下：

此时调用get(1,1),我们需要做的操作如下：

1.如果m中不存在key1，那么返回-1

2. 从freq中频率为1(从m中获取到的key对应的频率值)的list中将1删除

3. 将m中1对应的频率值自增1

4. 将1保存到freq中频率为2(当前频率加+1)的list的末尾

5. 在l中保存1在freq中频率为2的list中的位置

6. 如果freq中频率为minFreq的list为空，minFreq自增1

7. 返回m中1对应的value值

经过这些步骤后，我们再来看下此时内部容器情况：

此时再put(3, 3)，我们需要做的操作如下：

1. 先调用get(3)返回的结果不是-1，也就是说此时cache中已经存在3这块缓存了，我们可以直接将m中3对应的value更新为当前value，并返回。

2. 如果此时m的大小大于了cap，即超过了cache的容量，则：

　　a）在m中移除minFreq对应的list的首元素的key。

　　b）在l中清除3对应的纪录

　　c）在freq中移除minFreq对应的list的首元素。

3. 在m中建立3的映射，即 3 -> {value 3, frequent1}

4. 在freq中频率为1的list末尾加上3

5. 在l中保存3在freq中频率为1的list中的位置

6. minFreq重置为1

此时内部容器情况：

虚线表示此步骤删去的元素。

程序：

C++

class LFUCache {
public:
    LFUCache(int capacity) {
        cap = capacity;
    }

    int get(int key) {
        if(m.count(key) == 0)
            return -1;
        freq[m[key].second].erase(l[key]);
        m[key].second++;
        freq[m[key].second].push_back(key);
        l[key] = --freq[m[key].second].end();
        if(freq[minFreq].size() == 0)
            minFreq++;
        return m[key].first;
    }

    void put(int key, int value) {
        if(cap <= 0)
            return;
        if(get(key) != -1){
            m[key].first = value;
            return;
        }
        if(m.size() >= cap){
            m.erase(freq[minFreq].front());
            l.erase(freq[minFreq].front());
            freq[minFreq].pop_front();
        }
        m[key] = make_pair(value, 1);
        freq[1].push_back(key);
        l[key] = --freq[1].end();
        minFreq = 1;
    }

private:
    int cap, minFreq;
    unordered_map<int, pair<int, int>> m;
    unordered_map<int, list<int>> freq;
    unordered_map<int, list<int>::iterator> l;
};

/**
 * 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);
 */

Java

public class LFUCache {

    public LFUCache(int capacity) {
        cap = capacity;
        map = new HashMap<>();
        freq = new HashMap<>();
        list = new HashMap<>();
        minFreq = 1;
    }
    public int get(int key) {
        if(!map.containsKey(key))
            return -1;
        int count = freq.get(key);
        list.get(count).remove(key);
        freq.put(key, count + 1);
        if(list.get(minFreq).size() == 0)
            minFreq++;
        if(!list.containsKey(count + 1)){
            LinkedHashSet<Integer> set = new LinkedHashSet<Integer>();
            set.add(key);
            list.put(count+1, set);
        }else{
            list.get(count+1).add(key);
        }
        return map.get(key);
    }
    public void put(int key, int value) {
        if(cap <= 0)
            return;
        if(get(key) != -1){
            map.put(key, value);
            return;
        }
        if(map.size() >= cap){
            Integer removeKey = list.get(minFreq).iterator().next();
            map.remove(removeKey);
            list.get(minFreq).remove(removeKey);
            freq.remove(removeKey);
        }
        //System.out.println(map.toString());
        map.put(key, value);
        freq.put(key, 1);
        if(!list.containsKey(1)){
            LinkedHashSet<Integer> set = new LinkedHashSet<Integer>();
            set.add(key);
            list.put(1, set);
        }else{
            list.get(1).add(key);
        }
        minFreq = 1;
    }

    private int cap;
    private int minFreq;
    private HashMap<Integer, Integer> map;
    private HashMap<Integer, Integer> freq;
    private HashMap<Integer, LinkedHashSet<Integer>> list;
}

/**
 * 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);
 */