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。

居然还有这种东西！