一、题目描述

二、解题思路

  先来看一下什么是$LRU$缓存机制，假设只给一个进程分配三个页框，当发生缺页的时候，$OS$必须选择一个页面将其换出其所在的页框，这个被选择的页面，将是在现有页框中最久没有被使用过的那个。就拿下面这张图为例：

  比如我们现在处于第六步：要调入$3$号页面，那么应该从现有页面0、2、1中选择一个调出。由于在$3$号页面前面的序列是$7,0,1,2,0$，而现有页面是$0,2,1$，那么就找$0,2,1$这三个数字中在序列中最靠前的那个：第三个数字$1$。
  为此，我们可以维护一个序列，这个序列保存着分配的页框内的现存页面的访问顺序，其长度就是分配到的页框数：

• 序列不满（其$size$没有达到分配的页框数
  • 当前访问页面在序列内
    • 找到该页面在序列中的位置
    • 把该位置的元素挪移到序列尾
  • 当前访问页面不在序列内
    • 直接在序列末尾添加当前访问的页框
• 序列满
  • 当前访问页面在序列内
    • 将该页面挪移到序列末尾
    • 并更新该页面对应的值
  • 当前访问页面不在序列内
    • 由上面的分析我们其实可以发现，任意时刻序列的顺序就是访问的时间顺序，越靠前其访问得越早
    • 删掉序列开头的元素
    • 在序列末尾插入当前访问的序列
    • 完成页面的调入

这里还有两个地方有疑问

• 怎么确定页面是否在序列中，如果在，怎么确定其位置
• 怎么完成页面号与页面值的映射

  对于第一个问题，当然可以每次都遍历序列，然后找到结论，但是由于时间复杂度太大，因为运行超时，无法通过最后一个(第$18$个测试用例)。
对于第二个问题，解决映射问题完成$key$和$value$的对应，最好使用$unordered$$map$。
  针对第一个问题进行改进，不应该采用顺序结构，比如数组或者$vector$之类，因为如果需要挪移元素将耗费大量的时间。所以应该采用找到位置后可以直接链接的结构，也就是双向链表$list$。
  针对第二个问题，$unordered$$map$的$key$和$value$都是什么？考虑这样一种情况，如果$key$和$value$分别是页号和页面的值，那么即使根据映射从页号得到了页面值，也还是需要在$list$中找到对应$key$的那个页面并进行操作，时间复杂度还是没有降低。
所以想要根据$unordered$$map$的$key$直接找到序列中对应的位置，必须将$unordered$$map$的$value$直接映射成$list$的迭代器，指向要挪移的那个元素在$list$内的位置。所以$unordered$_$map$应该设计成unordered_map<int, list<pair<int, int>::iterator>，真正完成$key$与$value$的工作，由$list$来做。
  知道了思路，来整理下代码逻辑

• $get$操作
  • 如果$unordered$_$map$没有找到与$key$对应的迭代器，直接返回$-1$
  • 如果存在$key$对应的迭代器
    • 从$unordered$_$map$和$list$里把这个元素抹除
    • 更新后再放回到$list$的末尾
    • 重新建立$unordered$_$map$中关于$key$的映射，注意此时映射的迭代器应该是$list$末尾
• $put$操作：首先调用$get$，$get$一下
  • 如果$get$到元素
    • 这一定会导致$list$内顺序的改变，于是交给$put$的任务变成了更新$list$末尾元素值
  • 如果没有$get$到元素
    • 如果$list$未满
      • 在$list$末尾插入元素，并在$unordered$_$map$内建立起$key$和迭代器的对应
    • 如果$list$已满
      • 说明此时应该从$list$内选择开头的那个旧的页面调出内存，换入新的页面
      • 记录下要换出的页面的$key$
      • 抹掉$unordered$_$map$中和$key$对应的元素
      • 抹掉$list$开头的元素
      • 在$list$末尾插入新的页面
      • 在$unordered$$map$中建立起$key$和$list$末尾迭代器的映射
          注意在$get$操作的时候有一个大坑：抹掉$unordered$$map$对应元素的之前，一定要先保存一个拷贝，否则从被抹掉的位置得到的迭代器将指向未知的位置引发程序崩溃。
          做完这些，我们可以确保从$unordered$_$map$中根据$key$取得的任意一个迭代器指向的都是要进行操作的$list$的位置，降低了时间复杂度。

三、解题代码

class LRUCache
{
   
private:
    unordered_map<int, list<pair<int, int>>::iterator> ump;
    list<pair<int, int>> Lst;
    int MaxSize;
    int HowMuch;

public:
    LRUCache(int capacity)
    {
   
        HowMuch = 0;
        MaxSize = capacity;
    }

    int get(int key)
    {
   
        if (MaxSize <= 0)
            return -1;
        auto it = ump.find(key);
        int ret = -1;
        if (it != ump.end())
        {
                                //找到了
            ret = it->second->second; //val
            auto tmp = it->second;
            ump.erase(ump.find(key));
            Lst.erase(tmp);
            Lst.push_back(pair<int, int>(key, ret));
            ump.insert(make_pair(key, --Lst.end()));
        }
        return ret;
    }
    
    void put(int key, int value)
    {
   
        if (MaxSize <= 0)
            return;
        if (get(key) != -1)
        {
    //找到了
            Lst.rbegin()->second = value;
            return;
        }
        else
        {
   
            if (HowMuch < MaxSize)
            {
   
                Lst.push_back(make_pair(key, value));
                ump.insert(make_pair(key, --Lst.end()));
                HowMuch++;
                return;
            }
            else if (HowMuch == MaxSize)
            {
   
                auto rm_it = Lst.begin();
                ump.erase(ump.find(rm_it->first));
                Lst.erase(Lst.begin());
                Lst.push_back(make_pair(key, value));
                ump.insert(make_pair(key, --Lst.end()));
                return;
            }
        }
    }
};

四、运行结果

五、总结

• Lst.begin()和Lst.rbegin()不是同一类型的迭代器
  • Lst.begin()是正常的$list$迭代器
  • Lst.rbegin()是反向$list$迭代器
• $Java$有$LinkedHashMap$结构，如果$C++$也有的话，就不用费劲设计$list$了