leetcode 146. LRU Cache 460. LFU Cache

146. LRU Cache

Design and implement a data structure for Least Recently Used (LRU) 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 reached its capacity, it should invalidate the least recently used item before inserting a new item.

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

Example:

LRUCache cache = new LRUCache( 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.put(4, 4);    // evicts key 1
cache.get(1);       // returns -1 (not found)
cache.get(3);       // returns 3
cache.get(4);       // returns 4

题意：

实现一个LRU cache，最近最久未用淘汰算法，有两个操作get和put，get是访问，put是访问然后增加或者修改值，如果容量满了，淘汰最近最久未用的值。

可以使用list存储值，每次访问将先前的值删掉（如果存在），然后加入list的头。这样能保证尾部是最近最久未用的，删除的时候从尾部取就好了。因为要知道先前的位置，于是需要增加key对应的list中的位置。

注意：迭代器可以作为map的值，不能作为键。迭代器是引用，引用需初始化才能使用，不能直接比较大小。

代码：

class LRUCache
{
public:
    LRUCache(int capacity)
    {
        maxSize = capacity;
    }

    int get(int key)
    {
        if (index.find(key) == index.end()) return -1;
        int value=index[key]->second;
        data.erase(index[key]);
        data.push_front(make_pair(key,value));
        index[key]=data.begin();
        return value;
    }

    void put(int key, int value)
    {
        if (index.find(key) != index.end())
        {
            data.erase(index[key]);
            data.push_front(make_pair(key,value));
            index[key]=data.begin();
        }
        else
        {
            if (data.size() == maxSize)
            {
                index.erase(data.back().first);
                data.pop_back();
            }
            data.push_front(make_pair(key,value));
            index[key] = data.begin();
        }
    }

private:
    int maxSize;
    list<pair<int, int>> data;
    unordered_map<int, list<pair<int, int>>::iterator> index;
};

460. LFU Cache

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.

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 cache，最近最不常用淘汰算法，有两个操作get和put，get是访问，put是访问然后增加或者修改值，如果容量满了，淘汰最近最不常用的值。

因为涉及频度fre，所以一个map存(key，<value,fre>)，根据值能取到频度。

淘汰频度最小的，每个key可能在一个频度，再建一个键为fre的map存(fre,list<key>)，这样知道删除哪个key。

因为要删除list中的元素，只知道key是无法删除自己的，需要知道迭代器，在建一个map存key到list<key>迭代器的映射。

代码：

class LFUCache {
public:
    int size;
    unordered_map<int,pair<int,int>> mpkv;
    unordered_map<int,list<int>> mpfre;
    unordered_map<int,list<int>::iterator> mpiter;
    int minfre;

    LFUCache(int capacity) {
        size=capacity;
    }

    int get(int key) {
        if(mpkv.find(key)==mpkv.end()) return -1;
        int res=mpkv[key].first;
        int fre=mpkv[key].second;
        mpkv[key].second=fre+1;
        mpfre[fre].erase(mpiter[key]);
        if(fre==minfre&&mpfre[fre].size()==0) minfre++;
        if(mpfre.find(fre+1)==mpfre.end()){
            mpfre[fre+1].push_back(key);
            mpiter[key]=--mpfre[fre+1].end();
        }
        else{
            mpiter[key] = mpfre[fre+1].insert(mpfre[fre+1].end(),key);
        }
        return res;
    }

    void put(int key, int value) {
        if (size <= 0) return;
        if(mpkv.find(key)==mpkv.end()){
            //pop
            if(mpkv.size()==size){
                int popkey=mpfre[minfre].front();
//                cout<<"popkey:"<<popkey<<endl;
                mpfre[minfre].pop_front();
                mpkv.erase(popkey);
                mpiter.erase(popkey);
            }
//            cout<<"pushkey:"<<key<<" val:"<<value<<endl;
            minfre=1;
            //push
            mpkv[key]=make_pair(value,1);

            if(mpfre.find(1)==mpfre.end()){
                mpfre[1].push_back(key);
                mpiter[key]=--mpfre[1].end();
            }
            else{
                mpiter[key] = mpfre[1].insert(mpfre[1].end(),key);
            }
        }
        else{
            mpkv[key].first=value;
            get(key);
        }
    }
};