feat: add solutions to lc problem: No.0460 (doocs#1675)

No.0460.LFU Cache

Author: yanglbme

solution/0400-0499/0460.LFU Cache/README.md

@@ -69,17 +69,28 @@ lfu.get(4);      // 返回 4
 
 <!-- 这里可写通用的实现逻辑 -->
 
-和 [LRU 缓存](/solution/0100-0199/0146.Lru%20Cache/README.md) 类似的思路，用 `map<key, node>` 和 `map<freq, list<node>>` 存储不同使用频率的节点
+**方法一：双哈希表 + 双向链表**
 
-对于 `get` 操作，判断 key 是否存在哈希表中：
+我们定义两个哈希表，其中：
 
--   若不存在，返回 -1
--   若存在，增加节点的使用频率，返回节点值
+-   哈希表 $map$：用于存储缓存的键值对，哈希表的键 $key$ 对应到缓存节点 $node$，方便 $O(1)$ 时间内获取缓存节点。
+-   哈希表 $freqMap$：用于存储使用频率相同的缓存节点的双向链表，哈希表的键 $freq$ 对应到双向链表 $list$，方便 $O(1)$ 时间内获取使用频率相同的缓存节点的双向链表。
 
-对于 `put` 操作，同样判断 key 是否存在哈希表中：
+另外，我们还需要维护一个变量 $minFreq$，用于记录当前最小的使用频率，方便 $O(1)$ 时间内获取最小使用频率的缓存节点。
 
--   若不存在，首先判断缓存容量是否足够，不够的话需要先删除使用次数最少的节点。然后再创建新节点，插入使用频率为 1 的双链表
--   若存在，修改原节点的值，增加节点的使用频率
+对于 $get(key)$ 操作：
+
+我们首先判断 $capacity$ 是否为 $0$ 或者 $map$ 中是否存在键 $key$，如果不存在则返回 $-1$；否则从 $map$ 中获取缓存节点 $node$，并将 $node$ 的使用频率加 $1$，最后返回 $node$ 的值。
+
+对于 $put(key, value)$ 操作：
+
+我们首先判断 $capacity$ 是否为 $0$，如果为 $0$ 则直接返回；
+
+否则判断 $map$ 中是否存在键 $key$，如果存在则从 $map$ 中获取缓存节点 $node$，更新 $node$ 的值为 $value$，并将 $node$ 的使用频率加 $1$，最后返回 $node$ 的值；
+
+如果不存在则判断 $map$ 的长度是否等于 $capacity$，如果等于 $capacity$ 则从 $freqMap$ 中获取使用频率最小的双向链表 $list$，从 $list$ 中删除最后一个节点，并且移除该节点对应的键值对。然后创建新的缓存节点 $node$，将 $node$ 的使用频率设置为 $1$，将 $node$ 添加到 $map$ 和 $freqMap$ 中，最后将 $minFreq$ 设置为 $1$。
+
+时间复杂度方面，操作 $get$ 和 $put$ 的时间复杂度都是 $O(1)$。空间复杂度 $O(n)$，其中 $n$ 为缓存的容量。
 
 <!-- tabs:start -->
 
@@ -88,7 +99,94 @@ lfu.get(4);      // 返回 4
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Node:
+    def __init__(self, key: int, value: int) -> None:
+        self.key = key
+        self.value = value
+        self.freq = 1
+        self.prev = None
+        self.next = None
+
+
+class DoublyLinkedList:
+    def __init__(self) -> None:
+        self.head = Node(-1, -1)
+        self.tail = Node(-1, -1)
+        self.head.next = self.tail
+        self.tail.prev = self.head
+
+    def add_first(self, node: Node) -> None:
+        node.prev = self.head
+        node.next = self.head.next
+        self.head.next.prev = node
+        self.head.next = node
+
+    def remove(self, node: Node) -> Node:
+        node.next.prev = node.prev
+        node.prev.next = node.next
+        node.next, node.prev = None, None
+        return node
+
+    def remove_last(self) -> Node:
+        return self.remove(self.tail.prev)
+
+    def is_empty(self) -> bool:
+        return self.head.next == self.tail
+
+
+class LFUCache:
+    def __init__(self, capacity: int):
+        self.capacity = capacity
+        self.min_freq = 0
+        self.map = defaultdict(Node)
+        self.freq_map = defaultdict(DoublyLinkedList)
+
+    def get(self, key: int) -> int:
+        if self.capacity == 0 or key not in self.map:
+            return -1
+        node = self.map[key]
+        self.incr_freq(node)
+        return node.value
+
+    def put(self, key: int, value: int) -> None:
+        if self.capacity == 0:
+            return
+        if key in self.map:
+            node = self.map[key]
+            node.value = value
+            self.incr_freq(node)
+            return
+        if len(self.map) == self.capacity:
+            ls = self.freq_map[self.min_freq]
+            node = ls.remove_last()
+            self.map.pop(node.key)
+        node = Node(key, value)
+        self.add_node(node)
+        self.map[key] = node
+        self.min_freq = 1
+
+    def incr_freq(self, node: Node) -> None:
+        freq = node.freq
+        ls = self.freq_map[freq]
+        ls.remove(node)
+        if ls.is_empty():
+            self.freq_map.pop(freq)
+            if freq == self.min_freq:
+                self.min_freq += 1
+        node.freq += 1
+        self.add_node(node)
+
+    def add_node(self, node: Node) -> None:
+        freq = node.freq
+        ls = self.freq_map[freq]
+        ls.add_first(node)
+        self.freq_map[freq] = ls
+
+
+# Your LFUCache object will be instantiated and called as such:
+# obj = LFUCache(capacity)
+# param_1 = obj.get(key)
+# obj.put(key,value)
 ```
 
 ### **Java**
@@ -214,6 +312,132 @@ class LFUCache {
 }
 ```
 
+### **C++**
+
+```cpp
+class Node {
+public:
+    int key;
+    int value;
+    int freq;
+    Node* prev;
+    Node* next;
+    Node(int key, int value) {
+        this->key = key;
+        this->value = value;
+        this->freq = 1;
+        this->prev = nullptr;
+        this->next = nullptr;
+    }
+};
+
+class DoublyLinkedList {
+public:
+    Node* head;
+    Node* tail;
+    DoublyLinkedList() {
+        this->head = new Node(-1, -1);
+        this->tail = new Node(-1, -1);
+        this->head->next = this->tail;
+        this->tail->prev = this->head;
+    }
+    void addFirst(Node* node) {
+        node->prev = this->head;
+        node->next = this->head->next;
+        this->head->next->prev = node;
+        this->head->next = node;
+    }
+    Node* remove(Node* node) {
+        node->next->prev = node->prev;
+        node->prev->next = node->next;
+        node->next = nullptr;
+        node->prev = nullptr;
+        return node;
+    }
+    Node* removeLast() {
+        return remove(this->tail->prev);
+    }
+    bool isEmpty() {
+        return this->head->next == this->tail;
+    }
+};
+
+class LFUCache {
+public:
+    LFUCache(int capacity) {
+        this->capacity = capacity;
+        this->minFreq = 0;
+    }
+
+    int get(int key) {
+        if (capacity == 0 || map.find(key) == map.end()) {
+            return -1;
+        }
+        Node* node = map[key];
+        incrFreq(node);
+        return node->value;
+    }
+
+    void put(int key, int value) {
+        if (capacity == 0) {
+            return;
+        }
+        if (map.find(key) != map.end()) {
+            Node* node = map[key];
+            node->value = value;
+            incrFreq(node);
+            return;
+        }
+        if (map.size() == capacity) {
+            DoublyLinkedList* list = freqMap[minFreq];
+            Node* node = list->removeLast();
+            map.erase(node->key);
+        }
+        Node* node = new Node(key, value);
+        addNode(node);
+        map[key] = node;
+        minFreq = 1;
+    }
+
+private:
+    int capacity;
+    int minFreq;
+    unordered_map<int, Node*> map;
+    unordered_map<int, DoublyLinkedList*> freqMap;
+
+    void incrFreq(Node* node) {
+        int freq = node->freq;
+        DoublyLinkedList* list = freqMap[freq];
+        list->remove(node);
+        if (list->isEmpty()) {
+            freqMap.erase(freq);
+            if (freq == minFreq) {
+                minFreq++;
+            }
+        }
+        node->freq++;
+        addNode(node);
+    }
+
+    void addNode(Node* node) {
+        int freq = node->freq;
+        if (freqMap.find(freq) == freqMap.end()) {
+            freqMap[freq] = new DoublyLinkedList();
+        }
+        DoublyLinkedList* list = freqMap[freq];
+        list->addFirst(node);
+        freqMap[freq] = 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);
+ */
+```
+
 ### **Go**
 
 ```go