Question

我正在网上法官做练习：

设计并实现最近最少使用（LRU）缓存的数据结构。它应该支持以下操作：get和set。

get（key） - 如果密钥存在于缓存中，则获取密钥的值（将始终为正），否则返回-1。

设置（键，值） - 如果该键尚不存在，则设置或插入值。当缓存达到其容量时，它应该在插入新项目之前使最近最少使用的项无效。

我基本上使用std::list和std::unordered_map，并且在小输入情况下效果很好。但OJ在输入上超出了时间限制：缓存大小为2048和20000+ get＆amp;设置操作。

超出时限的版本：

class LRUCache {
public:
    LRUCache(int capacity):cacheSize(capacity) {

    }
    int get(int key) {
        auto it = mapping.find(key);
        if(it == mapping.end())
            return -1;
        itemList.splice(itemList.begin(),itemList,it->second);
        //mapping[key] == it->second still holds
        return it->second->second;
    }
    void set(int key, int value) {
        auto it = mapping.find(key);
        if(it != mapping.end()) {
            itemList.splice(itemList.begin(),itemList,it->second);
            it->second->second = value;
        } else {
            itemList.push_front(make_pair(key,value));
            mapping.insert(make_pair(key,itemList.begin()));
        }
        if(itemList.size() > cacheSize) {
            mapping.erase(itemList.back().first);
            itemList.pop_back();
        }
    }
private:
    int cacheSize;
    list<pair<int,int> > itemList;
    unordered_map<int,list<pair<int,int> >::iterator> mapping;
};

然后我想为什么不在插入之前擦除元素，所以我修改set函数并且OJ接受！

接受版本：

    void set(int key, int value) {
        auto it = mapping.find(key);
        if(it != mapping.end()) {
            itemList.splice(itemList.begin(),itemList,it->second);
            it->second->second = value;
        } else {
            if(itemList.size() == cacheSize) {
                mapping.erase(itemList.back().first);
                itemList.pop_back();
            }
            itemList.push_front(make_pair(key,value));
            mapping.insert(make_pair(key,itemList.begin()));
        }
    }

我想知道是什么造成了这样的不同？

Answer 1

原因是您使用的OJ使用具有线性复杂度std::list::size的C ++编译器。在C ++ 11中，它们要求它是常量，但在C ++ 98中它可能是线性的，并且许多实现实际上都是线性的。

请在complexity标签http://www.cplusplus.com/reference/list/list/size/

上查看C++98

我找到了您正在使用的OJ，并设法使用您的代码获取TLE，但设法通过一个小修改来接受它，它只跟踪列表的大小而不是调用size()

class LRUCache {
public:
    LRUCache(int capacity):cacheSize(capacity) {
        listSize = 0;
    }
    int get(int key) {
        auto it = mapping.find(key);
        if(it == mapping.end())
            return -1;
        itemList.splice(itemList.begin(),itemList,it->second);
        //mapping[key] == it->second still holds
        return it->second->second;
    }
    void set(int key, int value) {
        auto it = mapping.find(key);
        if(it != mapping.end()) {
            itemList.splice(itemList.begin(),itemList,it->second);
            it->second->second = value;
        } else {
            itemList.push_front(make_pair(key,value));
            ++ listSize;
            mapping.insert(make_pair(key,itemList.begin()));
        }
        if(listSize > cacheSize) {
            mapping.erase(itemList.back().first);
            -- listSize;
            itemList.pop_back();
        }
    }
private:
    int cacheSize;
    int listSize;
    list<pair<int,int> > itemList;
    unordered_map<int,list<pair<int,int> >::iterator> mapping;
};

LRU Cache C ++实现问题

1 个答案: