2024年5月15日-暑期实习-第一题（100分）-塔子哥的操作系统作业

在线评测链接

题目描述

\qquad 塔子哥有一门专业课，叫做操作系统，简称OS。操作系统的页式存储管理中，当主存满并且需要的存储页不在主存中，需要对主存中的页面进行置换，其中有一个非常重要的算法，即LRU置换算法。

\qquad LRU (Least Recently Used)缓存算法理一种常用于管理缓存的策略，其目标是保留最近使用过的数据,而淘汰最久未被使用的数据。实现简单的LRU缓存算法,支持查询、插入、删除操作。

\qquad 最久未被使用定义：查询、插入和删除操作均为一次访问操作，每个元素均有一个最后一次被访问时间,按照最后一次被访问时间排序，时间最早的即为最久未使用。插入操作：当缓存中已经存在，则刷新值，不存在，则插入，如果超过上限，则淘汰最久未被使用的元素。

输入描述

\qquad 第一行两个数N和K，分别表示缓存内最多可以存放页数，以及操作序列中的总操作数。其中N∈[1,100]，K∈[1,10000]。

\qquad 第二至第K+1行，每行两个输入，两个输入用空格分隔。第一个输入是一个字符$c{h}_i$：A表示插入，Q表示查询，D表示删除。第二个输入是一个整数$a_i$，表示一个页面的编号。其中$a_i$∈[1,100000]。

输出描述

\qquad 输出一行，表示缓存内各页面的编号，按照LRU优先级。

样例一

输入

2 5
A 103
A 102
A 102
Q 103
A 101

输出

101 103

解释

缓存大小为2，依次进行插入103、102，重复插入102，查询一次103，插入101时，最久未使用的元素为102，所以淘汰102。

Limitation

1s, 1024KiB for each test case.

思路

双向链表 + 哈希表

这是一道经典原题146. LRU缓存 。

每次查询或插入 key 成功后，都会更新 key 的优先级，这个优先级会影响大小满了之后，如何弹出旧元素，以有空间插入新元素。

朴素情况是，我们维护一个链表，每次遍历链表找到 key ，单次查找的时间复杂度是 $O(n)$ ，这会超时，考虑优化单次查找的时间。

单次查找这部分可以用哈希表来维护，这样插入和删除都是 $O(1)$

此外，我们还需要维护一个优先级，这个优先级可以用一个链表维护。

我们需要弹出 key ，所以要从链表中插入删除节点，这就需要链表的前后节点，所以用双向链表维护。

具体看代码实现。

时间复杂度：$O(n)$

代码

class DoubleLinkedNode:
    def __init__(self, key=0, value=0):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None


class LRUCache:

    def __init__(self, cap):
        self.cache = dict()
        self.head = DoubleLinkedNode()
        self.tail = DoubleLinkedNode()
        self.head.next = self.tail
        self.tail.prev = self.head
        self.cap = cap
        self.size = 0

    def output(self):
        temp = self.head.next
        ans = []
        while temp and temp != self.tail:
            ans.append(temp.value)
            temp = temp.next
        print(*ans)

    def get(self, key):
        if key not in self.cache:
            return -1
        node = self.cache[key]
        self.moveToHead(node)
        return node.value

    def put(self, key, value):
        if key not in self.cache:
            node = DoubleLinkedNode(key, value)
            self.cache[key] = node
            self.addToHead(node)
            self.size += 1
            if self.size > self.cap:
                removed = self.removeTail()
                self.cache.pop(removed.key)
                self.size -= 1
        else:
            node = self.cache[key]
            node.value = value
            self.moveToHead(node)

    def addToHead(self, node):
        node.prev = self.head
        node.next = self.head.next
        self.head.next.prev = node
        self.head.next = node

    def removeNode(self, node):
        node.prev.next = node.next
        node.next.prev = node.prev

    def moveToHead(self, node):
        self.removeNode(node)
        self.addToHead(node)

    def removeTail(self):
        node = self.tail.prev
        self.removeNode(node)
        return node


ans = []
cap, q = map(int, input().split())
lrucache = LRUCache(cap)

for i in range(q):
    line = input().split()
    op, key = line[0], int(line[1])
    if op == 'Q':
        lrucache.get(key)
    else:
        lrucache.put(key, key)

lrucache.output()