#include <bits/stdc++.h>
using namespace std;
/**
* FIFO算法的实现：其实是可以采用双端队列，然后限制一下
* 双端队列的长度，根据我的限制应该是4。对于查询是否出现
* 在这个队列里面，我们可以采用一个数组标记是否有存在。
*
* 测试数据如下
16 4
0 1 2 4 3 4 5 1 2 5 1 2 3 4 5 6
* **/
struct FIFO{
int len, m;///长度, len - 总访问数; m - 分配的物理块数
int arr[105];///存储访问页面的编号
deque<int>que;
int vids[15];///标记数组，标记在当前可以查找到的序号
double result;
int a;///a - 非缺页数
void Print(deque<int>a){
while(!a.empty()){
printf("%d ", a.front());
a.pop_front();
}
printf("\n");
}
void Init(){///初始化函数
while(!que.empty()){
que.pop_back();
}
memset(vids, 0, sizeof(vids));
}
void solve(){
scanf("%d%d", &len, &m);///输入处理的数字的长度，输入有多少可用物理块
for(int i = 0; i < len; i ++){
scanf("%d", &arr[i]);///预先输入处理的数据
}
int r = 0;///从第一个数据开始判断
while(r < len){///如果没有到达尾部,接着运行
if(!vids[arr[r]]){///如果不在物理块中
a ++;///非缺页数加一
printf("*: ");
if(que.size() < m){///物理块的储存的内容小于m
que.push_back(arr[r]);///则将序号放入双端队列
}
else{///数量超过了，要实现的是弹出队头，然后把在队列中的标记去掉
int nums = que.front();///获取队头元素
que.pop_front();///弹出队头
vids[nums] --;///把出现过的标志去掉
que.push_back(arr[r]);///队列压入新的元素
}
vids[arr[r]] ++;///把对应的元素的值++
}
Print(que);
r ++;///移动到下一个元素
}
printf("Number of page breaks = %d Total number of visits = %d\n", a, len);
result = double(a) / double(len);
printf("f = %f\n", result);
}
}f;
int main(){
f.Init();
f.solve();
}
#include <bits/stdc++.h>
using namespace std;
/**
* LRU算法的实现：可以使用一个结构体，来储存对应的数据
* 那么使用一个vector动态数组来储存当前的物理块中的内容
* 那么每访问一次就更新结构体中的value值，那么对vector数组
* 进行对应sort排序,即按照value从大到小排序，然后每次弹出队尾
* 将最小的value值的结构体弹出
* 测试数据如下
16 4
0 1 2 4 3 4 5 1 2 5 1 2 3 4 5 6
* **/
struct LRU_node{///LRU的节点结构
int key, value;///key代表节点最后一次出现的序号，value代表节点的权值
};
bool cmp(const LRU_node &a, const LRU_node &b){
return a.key > b.key;///排序，自定义排序cmp方法
}
struct LRU{
int arr[105];///arr即存储当前的数据
vector<LRU_node>vec;///动态数组储存节点
int vids[105];///标记数组
void Init(){///清空函数
memset(vids, 0, sizeof(vids));
memset(arr, 0, sizeof(arr));
vec.clear();
}
void slove(){
int n, m;
scanf("%d%d", &n, &m);///n 代表输入的序列的长度是多少， m代表物理块的大小
for(int i = 0; i < n; i ++){
scanf("%d", &arr[i]);
}
int flag = 0;///缺页数
int r = 0;///遍历边界
while(r < n){
LRU_node a;
a.key = r;
a.value = arr[r];///获取一个节点
if(!vids[a.value]){///物理块中没有这个数
flag ++;///缺页数加一
printf("*: ");///代表缺页
if(vec.size() < m){///vec的数量小于物理块m
vec.push_back(a);
vids[a.value] ++;///标记块中出现的数
sort(vec.begin(), vec.end(), cmp);///排序，保证弹出的肯定是时间最开始的那个
}
else{///vec的数量等于物理块的大小
sort(vec.begin(), vec.end(), cmp);///排序
LRU_node en = vec[vec.size() - 1];///取出最后的那个即时间最开始的那个
vids[en.value] --;///把弹出的数去掉
vec.pop_back();
vec.push_back(a);///把新的值压入vec
vids[a.value] ++;///标记新的值在块中出现
sort(vec.begin(), vec.end(), cmp);///排序
}
for(int i = 0; i < vec.size(); i ++){
printf("%d ", vec[i].value);
}
printf("\n");
}
else{///否则在块中有对应的数
for(int i = 0; i < vec.size(); i ++){///遍历块中数据
if(vec[i].value == a.value){
vec[i].key = a.key;///更新块中的数据所对应的key值，即出现的最后的时间
break;
}
}
sort(vec.begin(), vec.end(), cmp);///排序
for(int i = 0; i < vec.size(); i ++){
printf("%d ", vec[i].value);
}
printf("\n");
}
r ++;
}
printf("Number of page breaks = %d Total number of visits = %d\n", flag, n);
printf("f = %lf\n", double(flag) / double(n));
}
}l;
int main(){
l.Init();
l.slove();
return 0;
}
#include <bits/stdc++.h>
/**
* 思路：采用队列来保存每个每个值对应的下一个出现的位置
* 如果只后都不出现，那就把这个值置为无穷大，那么这样的
* 话就能保证这个值，会被先弹出动态数组，那么就能保证实
* 现对应的按照最远出现的位置来淘汰对应的数字。
* **/
using namespace std;
const int MAXN = 105;///可以控制出现的编号的范围，我假设只会出现105以内的数字
const int inf = 0x7fffffff;///int 的最大值，代表这个数再也不会出现
int n, m;///n 代表序列的长度， m代表物理块的大小
queue<int>que[MAXN];///记录下一个该数字出现的位置
int arr[MAXN];///储存序列
int vids[MAXN];///标记块中是否存在这个
bool cmp(const int &a, const int &b){
return que[a].front() < que[b].front();///按照下一次出现的位置从小到大排序
///保证可以将最远访问的块进行更换
}
struct opt{
void Init(){///清空
for(int i = 0; i < MAXN; i ++){///清空队列
while(!que[i].empty()){
que[i].pop();
}
}
memset(vids, 0, sizeof(vids));///清空标记数组
memset(arr, 0, sizeof(arr));///清空数组
return ;
}
void solve(){
int f = 0;///缺页数
scanf("%d%d", &n, &m);
Init();
for(int i = 0; i < n; i ++){
scanf("%d", &arr[i]);
que[arr[i]].push(i);///将对应的出现的位置放入队列中
}
for(int i = 0; i < MAXN; i ++){
que[i].push(inf);///全部放入完成后，放入一个无穷大
///这样的好处是如果这个数，后面不再出现，就视为无穷大
}
int r = 0;
vector<int>vec;///物理块使用动态数组模拟
vec.clear();
while(r < n){
if(!vids[arr[r]]){///如果在物理块中没有出现
f ++;///对应的缺页数加一
printf("*: ");///代表缺页
if(vec.size() < m){///如果没有达到物理块上限
vec.push_back(arr[r]);///动态数组压入对应的物理块
vids[arr[r]] ++;///标记物理块存在出现
que[arr[r]].pop();///把对应的位置弹出，使其更新为下一个最近的位置
}
else{
sort(vec.begin(), vec.end(), cmp);///否则达到上限,按照后面出现的位置排序
int temp = vec[vec.size() - 1];///获取队尾的数值
vids[temp] --;///把对应的数值的出现标记抹去
vec.pop_back();///将队尾弹出
vec.push_back(arr[r]);///压入新的数值
vids[arr[r]] ++;///把对应的数值的出现标记更新
que[arr[r]].pop();///把对应新的数值的下一个出现的位置进行更新
}
/**输出物理块中的内容**/
for(int i = 0; i < vec.size(); i ++){
printf("%d ", vec[i]);
}
printf("\n");
}
else{
que[arr[r]].pop();///在物理块中，将对应的值的后续的出现位置进行更新
sort(vec.begin(), vec.end(), cmp);///按照出现的位置的远近排序
for(int i = 0; i < vec.size(); i ++){///输出块中的内容
printf("%d ", vec[i]);
}
printf("\n");
}
r ++;
}
printf("Number of page breaks = %d Total number of visits = %d\n", f, n);
printf("%f\n", double(f) / double(n));
}
}a;
/**
测试样例如下：
12 3
2 3 2 1 5 2 4 5 3 2 5 2
**/
int main(){
a.solve();
return 0;
}
#include <bits/stdc++.h>
using namespace std;
/**
* 思路：lfu的实现，可以使用Map<int, int>来实现计数
* 或者使用int数组来标记出现的次数，然后每次进行对次数
* 的排序就行了，然后每次淘汰访问次数最小的就ok了，如果
* 数据范围较小的话，使用int数组来标记的话，把每次查询的
* 复杂度降到O(1)，所以下面的代码实现使用数组来标记出现的
* 次数
* **/
const int MAXN = 105;
int flag[MAXN]; ///下标代表出现的数值，下标里的数值代表被访问的次数
bool cmp(const int &a, const int &b)
{ ///按照被访问的次数进行从大到小的排序
return flag[a] > flag[b]; ///这样能保证更换物理块的时候是按照出现的次数最小的被更换
}
struct LFU
{
vector<int> vec;///代表物理块
int vids[MAXN];///代表物理块中出现的数
int n, m;
void Init()///初始化函数
{
vec.clear();
memset(vids, 0, sizeof(vids));
memset(flag, 0, sizeof(flag));
}
void solve()
{
int f = 0;///缺页数
scanf("%d%d", &n, &m);
Init();
for (int i = 0; i < n; i++)
{
int num;
scanf("%d", &num);///输入一个值
if (!vids[num])///判断是否在物理块中
{
f ++;
printf("*: ");
if (vec.size() < m)///如果数量小于物理块的数量
{
vec.push_back(num);///直接压入物理块
vids[num]++;///标记其出现
flag[num]++;///对应的出现次数加一
}
else
{
sort(vec.begin(), vec.end(), cmp);///针对出现的次数排序
int temp = vec[vec.size() - 1];///获取出现次数最小的数的值
vids[temp]--;///将其标记去掉
flag[temp] = 0;///将其访问的次数变为0
vec.pop_back();///将其弹出队列
vec.push_back(num);///将新的值压入内存块
vids[num]++;///将新的值标记出现
flag[num]++;///将新的值得出现次数加一
}
sort(vec.begin(), vec.end(), cmp);///排序
for (int i = 0; i < vec.size(); i++)///输出物理块
{
printf("%d ", vec[i]);
}
printf("\n");
}
else
{
flag[num]++;///在物理块中，将访问值加一
sort(vec.begin(), vec.end(), cmp);///排序
for (int i = 0; i < vec.size(); i++)///输出物理块的情况
{
printf("%d ", vec[i]);
}
printf("\n");
}
}
printf("Number of page breaks = %d Total number of visits = %d\n", f, n);
printf("%f\n", double(f) / double(n));
}
} a;
int main()
{
a.solve();
return 0;
}
