Leetcode 146. LRU緩存機制（HASH）

運用你所掌握的數據結構，設計和實現一個 LRU (最近最少使用) 緩存機制。它應該支持以下操作： 獲取數據 get 和 寫入數據 put 。
獲取數據 get(key) - 如果密鑰 (key) 存在於緩存中，則獲取密鑰的值（總是正數），否則返回 -1。
寫入數據 put(key, value) - 如果密鑰已經存在，則變更其數據值；如果密鑰不存在，則插入該組「密鑰/數據值」。當緩存容量達到上限時，它應該在寫入新數據之前刪除最久未使用的數據值，從而爲新的數據值留出空間。
進階:
你是否可以在 O(1) 時間複雜度內完成這兩種操作？

示例:
LRUCache cache = new LRUCache( 2 /* 緩存容量 */ );
cache.put(1, 1);
cache.put(2, 2);
cache.get(1); // 返回 1
cache.put(3, 3); // 該操作會使得密鑰 2 作廢
cache.get(2); // 返回 -1 (未找到)
cache.put(4, 4); // 該操作會使得密鑰 1 作廢
cache.get(1); // 返回 -1 (未找到)
cache.get(3); // 返回 3
cache.get(4); // 返回 4

自行yy了一個效率比較低的O(1)算法
使用hash可以O(1)映射（unordered_map）

問題是緩存滿了刪哪個？這個key到value的映射沒有時間信息，可以用一個隊列（或者說數組）記錄插入/訪問順序，當插入/訪問key1時，把它放入隊尾，這樣每次刪隊頭的那個就可以了，問題又來了，如果key1本來就在隊列中，要把它刪掉再放隊尾，這個刪不是O(1)的，解決方法是不刪它只是入隊，再用一個hash映射vis[key1]記錄隊列裏有多少個key1,只有最後一個key1纔有效，類似惰性刪除

class LRUCache {
    int capacity;
    queue<int> q;
    unordered_map<int,int> k2v;
    unordered_map<int,int> vis;
public:
    LRUCache(int capacity) {
        this->capacity = capacity;
    }

    int get(int key) {
        if (!k2v.count(key))
            return -1;
        q.emplace(key);
        vis.at(key)++;
        return k2v.at(key);
    }

    void put(int key, int value) {
        if (!vis.count(key))
            vis.insert(make_pair(key,0));
        if (vis.at(key) > 0) {
            k2v.erase(key);
        }
        if (k2v.size() == capacity) {
            while (1) {
                int dkey = q.front();
                q.pop();
                vis.at(dkey)--;
                if (k2v.count(dkey) && vis.at(dkey)==0) {
                    k2v.erase(dkey);
                    vis.erase(dkey);
                    break;
                }
            }
        }
        q.emplace(key);
        k2v.insert(make_pair(key,value));
        vis.at(key)++;
    }
};

官方題解：
有一種叫做有序字典的數據結構，綜合了哈希表和鏈表，在 Python 中爲 OrderedDict，在 Java 中爲 LinkedHashMap。

居然還有這種東西！