460LFU 缓存（双哈希表、set+哈希表）

最新推荐文章于 2023-01-30 13:52:56 发布

Revendell

最新推荐文章于 2023-01-30 13:52:56 发布

阅读量291

点赞数

分类专栏： LeetCode 文章标签：算法 leetcode

本文链接：https://blog.csdn.net/Revendell/article/details/115560525

版权

LeetCode 专栏收录该内容

368 篇文章 20 订阅

订阅专栏

1、题目描述

请你为最不经常使用（LFU）缓存算法设计并实现数据结构。

实现 LFUCache 类：

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

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

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

提示：

0 <= capacity, key, value <= 104
最多调用 105 次 get 和 put 方法

进阶：你可以为这两种操作设计时间复杂度为 O(1) 的实现吗？

2、示例

输入：
["LFUCache", "put", "put", "get", "put", "get", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [3], [4, 4], [1], [3], [4]]
输出：
[null, null, null, 1, null, -1, 3, null, -1, 3, 4]

解释：
// cnt(x) = 键 x 的使用计数
// cache=[] 将显示最后一次使用的顺序（最左边的元素是最近的）
LFUCache lFUCache = new LFUCache(2);
lFUCache.put(1, 1); // cache=[1,_], cnt(1)=1
lFUCache.put(2, 2); // cache=[2,1], cnt(2)=1, cnt(1)=1
lFUCache.get(1); // 返回 1
// cache=[1,2], cnt(2)=1, cnt(1)=2
lFUCache.put(3, 3); // 去除键 2 ，因为 cnt(2)=1 ，使用计数最小
// cache=[3,1], cnt(3)=1, cnt(1)=2
lFUCache.get(2); // 返回 -1（未找到）
lFUCache.get(3); // 返回 3
// cache=[3,1], cnt(3)=2, cnt(1)=2
lFUCache.put(4, 4); // 去除键 1 ，1 和 3 的 cnt 相同，但 1 最久未使用
// cache=[4,3], cnt(4)=1, cnt(3)=2
lFUCache.get(1); // 返回 -1（未找到）
lFUCache.get(3); // 返回 3
// cache=[3,4], cnt(4)=1, cnt(3)=3
lFUCache.get(4); // 返回 4
// cache=[3,4], cnt(4)=2, cnt(3)=3

3、题解

解法一：双哈希表

min_freq
1<-->2<-->3<-->4  ：unordered_map<int,list<Node>> freq_table
|    |
kv   kv           ：unordered_map<int,list<Node>::iterator> key_table
|    |
kv   kv

定义两个哈希表，第一个 freq_table 以频率 freq 为索引，每个索引存放一个双向链表，这个链表里存放所有使用频率为 freq 的缓存，缓存里存放三个信息，分别为键 key，值 value，以及使用频率 freq。第二个 key_table 以键值 key 为索引，每个索引存放对应缓存在 freq_table 中链表里的内存地址，这样我们就能利用两个哈希表来使得两个操作的时间复杂度均为 O(1)。同时需要记录一个当前缓存最少使用的频率 minFreq，这是为了删除操作服务的。

解法二：set+哈希表

用红黑树存储Node节点，按照cnt频次和time时间戳来排序，起始节点就是将会被剔除的节点，通过哈希表key查找到相应的Node。

#include<iostream>
#include<algorithm>
#include<vector>
#include<unordered_map>
#include<set>
using namespace std;
class LFUCache {
public:
    struct Node{
        int key,value,freq;
        Node(int _key,int _val,int _freq): key(_key), value(_val), freq(_freq){}
    };
    LFUCache(int capacity) {
        this->capacity=capacity;
        min_freq=0;
    }
    
    int get(int key) {
        if (capacity == 0) return -1;
        if(key_table.find(key)==key_table.end())  return -1;
        auto iter=key_table.find(key)->second;
        int freq=iter->freq,value=iter->value;
        freq_table[freq].erase(iter);
        if(freq_table[freq].size()==0)
        {
            freq_table.erase(freq);
            if (min_freq == freq) min_freq += 1;
        }
        freq_table[freq+1].push_front(Node(key,value,freq+1));
        key_table[key]=freq_table[freq+1].begin();
        return value;
    }
    
    void put(int key, int value) {
        if (capacity == 0) return;
        if(key_table.find(key)==key_table.end())
        {
            if(key_table.size()==capacity)
            {
                auto iter=freq_table[min_freq].back();
                int key=iter.key,freq=iter.freq;
                freq_table[min_freq].erase(key_table[key]);
                key_table.erase(key);
            }
            min_freq=1;
            freq_table[1].push_front(Node(key,value,1));
            key_table[key]=freq_table[1].begin();
        }
        else
        {
            auto iter=key_table.find(key)->second;
            int freq=iter->freq;
            freq_table[freq].erase(iter);
            if(freq_table[freq].size()==0)
            {
                freq_table.erase(freq);
                if (min_freq == freq) min_freq += 1;
            }
            freq_table[freq+1].push_front(Node(key,value,freq+1));
            key_table[key]=freq_table[freq+1].begin();
        }
    }
private:
    int min_freq,capacity;
    unordered_map<int,list<Node>> freq_table;
    unordered_map<int,list<Node>::iterator> key_table;
};
class LFUCache {
public:
    struct Node{
        int key,value;
        int cnt;
        int time;
        Node() {}
        Node(int _cnt, int _time, int _key, int _value):cnt(_cnt), time(_time), key(_key), value(_value){}
        bool operator< (const Node& rhs) const {
            return cnt == rhs.cnt ? time < rhs.time : cnt < rhs.cnt;
        }
    };
    
    LFUCache(int capacity) {
        this->capacity=capacity;
        this->time=0;
    }
    
    int get(int key) {
        if(keyMap.find(key)!=keyMap.end())
        {
            Node tmp=keyMap[key];
            listNode.erase(tmp);
            tmp.time=++time;
            tmp.cnt++;
            listNode.insert(tmp);
            keyMap[key]=tmp;
            return tmp.value;
        }
        else
            return -1;
    }
    
    void put(int key, int value) {
        if(capacity==0)
            return;
        if(keyMap.find(key)!=keyMap.end())
        {
            Node tmp=keyMap[key];
            listNode.erase(tmp);
            tmp.time=++time;
            tmp.cnt++;
            tmp.value=value;
            listNode.insert(tmp);
            keyMap[key]=tmp;
            return;
        }
        else
        {
            if(keyMap.size()==capacity)
            {
                keyMap.erase(listNode.begin()->key);
                listNode.erase(listNode.begin());
            }
            Node tmp=Node(1,++time,key,value);
            listNode.insert(tmp);
            keyMap.insert({key,tmp});
            return;
        }
    }
private:
    int capacity,time;
    set<Node> listNode;
    unordered_map<int,Node> keyMap;
};
int main()
{
    LFUCache* obj = new LFUCache(2);
    int param_1 = obj->get(0);
    cout<<param_1<<endl;
    return 0;
}