[JSOI2010]缓存交换(优先队列的应用)

辞.198

已于 2022-11-29 17:56:01 修改

阅读量230

点赞数 4

分类专栏：算法

于 2022-07-07 20:13:03 首次发布

本文链接：https://blog.csdn.net/weixin_62238042/article/details/125665042

版权

c++ 算法

算法专栏收录该内容

4 篇文章 0 订阅

订阅专栏

传送门（题目链接）

题目描述：（很长但意思简单）

在计算机中，CPU只能和高速缓存Cache直接交换数据。当所需的内存单元不在Cache中时，则需要从主存里把数据调入Cache。此时，如果Cache容量已满，则必须先从中删除一个。

例如，当前Cache容量为3，且已经有编号为10和20的主存单元。此时，CPU访问编号为10的主存单元，Cache命中。接着，CPU访问编号为21的主存单元，那么只需将该主存单元移入Cache中，造成一次缺失（Cache Miss）。接着，CPU访问编号为31的主存单元，则必须从Cache中换出一块，才能将编号为31的主存单元移入Cache，假设我们移出了编号为10的主存单元。接着，CPU再次访问编号为10的主存单元，则又引起了一次缺失。

我们看到，如果在上一次删除时，删除其他的单元，则可以避免本次访问的缺失。在现代计算机中，往往采用LRU(最近最少使用)的算法来进行Cache调度——可是，从上一个例子就能看出，这并不是最优的算法。

对于一个固定容量的空Cache和连续的若干主存访问请求，聪聪想知道如何在每次Cache缺失时换出正确的主存单元，以达到最少的Cache缺失次数。

输入：n（主动访问次数），m（Cache的容量）

输出：最小的缺失次数

example：6 2
1 2 3 1 2 3（首先Cache为空，1 2进入，缺失了两次，3进入（缺失），用3把2换掉，Cache中（1,3），1进入（Cache中已有），2进入（Cache中没有，缺少4次），用2把1换掉，Cache中（2,3），最后3进入。

所以最优的答案是4。

题目分析：我们要得到最小的缺失次数，那么与我们在Cache中选择换那块直接相关，我最先想的是换掉后面出现最多的，但这不是最优解，如 Cache容量为3 ，访问的顺序为 1 2 3 4 2 1 2 1 3 3 3 3 3 3 3

当4进入时，Cache已满且3在后面出现的次数最多，那么我们换2

Cache（1 2 3） 4 2 1 2 1 3 3 3 3 3 （1）

Cache（1 4 3） 2 1 2 1 3 3 3 3 3 （2）

Cache（2 4 3） 1 2 1 3 3 3 3 3 （3）

Cache（2 1 3） 2 1 3 3 3 3 3

可以看到缺失了4次

而另一种贪心的思想，我们把当前在内存中的下一次出现的最晚的换掉

Cache（1 2 3） 4 2 1 2 1 3 3 3 3 3 （1）

Cache（1 2 4） 2 1 2 1 3 3 3 3 3

Cache（1 2 4） 3 3 3 3 3 （2）

Cache（1 2 3） 3 3 3 3

虽然3在后面出现的次多，但下一个3出现的位置最晚，所以我们把3换掉，最终只缺失了2次。

所以最优的策略是换掉当前Cache中下一个位置出现最晚的元素。

需要一个优先队列（不断取当前Cache中下一次出现最晚的那个元素的位置），

用s[i],表示每一个元素，当然也要一个nex[i]数组，nex[i]表示s[i]下一次出现的位置

用一个bool数组vis[i],表示下一个位置为i的元素是否在Cache中（元素s[i]在Cache中，与s[i]相同的下一个元素的位置i标记为真，即当遇到vis[i]为真，表示s[i]这个元素已在Cache中）。

直接看注释吧（虽然我也觉得很难理解_--_）

#include<iostream>
#include<string>
#include<memory.h>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<algorithm>
#include<functional>
#include<cmath>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int N = 1e5 + 7;
const int inf = 0x3f3f3f3f;
bool vis[N]; //
int s[N];    //
int nex[N];
void solve()
{
    int n, m;
    priority_queue<int>q;
 
    cin >> n >> m;
    for (int i = 1; i <= n; i++) { cin >> s[i]; vis[i] = 0; nex[i] = 0; }
    map<int, int>mp;
    for (int i = n; i >= 1; i--)  //模板，表示位置为i的元素，下一次出现的位置
    {
   //与最后一个s[i]相同的下一个s[i]，当然没有，所以赋值超出总位置的个数，表示无限大
        if (mp[s[i]] == 0)
            nex[i] = 100000 + 3; 
        else nex[i] = mp[s[i]]; //更新从后往前最新一次记录s[i]的位置 
        mp[s[i]] = i;
    }
    int ans = 0;//缺失次数
    int num = 0;//Cache容量
    for (int i = 1; i <= n; i++)
    {
        if (vis[i] == 0)//下一次s[i]的位置没在Cache中，当然s[i]也没做Cache中  
        {
            ans++;
            if (num < m) //Cache未满
            {
                num++;  //Cache已装数+1
                vis[nex[i]] = 1;// s[i]进入Cache,下一次s[i]的位置标记为1
                q.push(nex[i]); //s[i]下一次出现的位置，push进队列
            }
            else   //Cache已满          
            {
             
                vis[q.top()] = 0;// 被换掉的元素的下一次位置标记为0
                  q.pop();//把Cache中元素下一次出现最晚的元素换掉
                vis[nex[i]] = 1; //s[i]进入Cache中，下次s[i]出现的位置标记为0
                q.push(nex[i]);//下一次s[i]出现的位置push入队
            }
        }
        else// s[i]所表示的元素仍在Cache中，所以是s[i]的下一次位置仍标记的为1
        {
        //s[i]元素已在Cache中，又遇到s[i]这个元素 
            vis[nex[i]] = 1;//将新s[i]下一次出现的位置标记为1
            q.push(nex[i]);//将新s[i]下一次出现的位置入队
       //优先队列，之前入队的位置一定比后入队的位置的坐标值小，所以无影响
        }
    }
    cout << ans << endl;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
 
    int t = 1;
    //    cin>>t;
    while (t--)
        solve();
    return 0;
 
}