LRU算法，走迷宫，数根，星际战争

问答题1

问答题1：一进程刚获得三个主存块的使用权，若该进程访问页面的次序是｛1321215123｝，采用 LRU 算法，缺页数是几次？

LRU 算法是先置换出不常用的页面，如果一个页面刚刚被访问过，那么会放到队列尾部

先进先出算法：不管页面是否常用，都按照先进先出的思想进行置换页面.

下面是LRU算法

访问页面	1	3	2	1	2	1	5	1	2	3
物理块1	1	1	1	3	3	3	2	2	5	1
物理块2		3	3	2	1	2	1	5	1	2
物理块3			2	1	2	1	5	1	2	3
是否缺页	是	是	是	否	否	否	是	否	否	是

1 代表缺页，0 代表不缺页，所以缺页数是5次

下面是先进先出算法：

访问页面	1	3	2	1	2	1	5	1	2	3
物理块1	1	1	1	1	1	1	3	2	2	5
物理块2		3	3	3	3	3	2	5	5	1
物理块3			2	2	2	2	5	1	1	3
是否缺页	是	是	是	否	否	否	是	是	否	是

置换了6次页面.

问答题2：啥是可重入函数？
可重入函数主要用于多任务环境中，简单来说就是可以被中断的函数，即在这个函数执行的任何时刻中断它，转入OS调度下去执行另外一段代码，返回控制时不会出现什么错误；也意味着它除了使用自己栈上的变量以外不依赖于任何环境（包括static），这样的函数就是 purecode（纯代码）可重入，可以允许有该函数的多个副本在运行，由于它们使用的是分离的栈，所以不会互相干扰。

问答题3：啥是不可重入函数？

而不可重入的函数由于使用了一些系统资源，比如全局变量区、中断向量表等，所以它如果被中断的话，可能会出现问题，这类函数是不能运行在多任务环境下的。

可重入函数确实需要访问全局变量（包括 static），一定要注意实施互斥手段。它在并行运行环境中非常重要，但是一般要为访问全局变量付出一些性能代价。编写可重入函数时，若使用全局变量，则应通过关中断、信号量（即P、V操作）等手段对其加以保护。

问答题4：使用C语言将一个1G字节的字符数组从头到尾全部设置为字’A’，在一台典型的当代PC上，需要花费的CPU时间的数量级接近多少秒？

当代典型PC机运算速度可达10亿次/秒（109），即执行一条典型指令 1/1,000,000,000秒 = 1 纳秒

1GB = 2 的 30 次方 B = 8的10次方 B（8的10次方大小为10亿多一点）

编程题

编程题1：年终奖

小东所在公司要发年终奖，而小东恰好获得了最高福利，他要在公司年会上参与一个抽奖游戏，游戏在一个6*6的棋盘上进行，上面放着 36 个价值不等的礼物，每个小的棋盘上面放置着一个礼物，他需要从左上角开始游戏，每次只能向下或者向右移动一步，到达右下角停止，一路上的格子里的礼物小东都能拿到，请设计一个算法使小东拿到价值最高的礼物

给定一个6*6的矩阵 board，其中每个元素为对应格子的礼物价值,左上角为[0,0],请返回能获得的最大价值，保证每个礼物价值大于100小于1000

提示：动态规划

初始化二维数组的第一行和第一列，进行迭加

动态方程为 v[i][j] = max(v[i-1][j],v[i][j-1])+board[i][j] 表示当前最大值是上面的元素和左边元素的较大值然后再加上当前元素的值.

最后返回数组的最后一个值.

class Bonus {public:int getMost(vector<vector<int> > board) {int row = board.size();int col = board[0].size();vector<vector<int>>v(row,vector<int>(col,0));v[0][0] = board[0][0];for(int i= 0;i<row;++i){for(int j = 0;j<col;++j){if(i==0 && j==0){continue;}else if(i == 0){v[i][j] = v[i][j-1]+board[i][j]; }else if(j==0){v[i][j] = v[i-1][j] + board[i][j];}else{v[i][j] = max(v[i-1][j],v[i][j-1])+board[i][j];}}}return v[row-1][col-1];}
};

编程题2：迷宫问题

定义一个二维数组N*M（其中2<=N<=10;2<=M<=10），如5 × 5数组下所示

int maze[5][5] = {0, 1, 0, 0, 0,0, 1, 0, 1, 0,0, 0, 0, 0, 0,0, 1, 1, 1, 0,0, 0, 0, 1, 0,
};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。入口点为[0,0],既第一空格是可以走的路

输入：
5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

输出:
(0,0)
(1,0)
(2,0)
(2,1)
(2,2)
(2,3)
(2,4)
(3,4)
(4,4)
数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道

提示：MazeTrack()函数用来递归走迷宫，具体步骤为：

首先将当前点加入路径，并设置为已走
判断当前点是否为出口，如果到了出口则输出路径，保存结果；跳转到4
依次判断当前点的上、下、左、右四个点是否可走，如果可走则递归走该点
当前点推出路径，设置为可走

#include<iostream>
#include<vector>
using namespace std;int N, M; //分别代表行和列
vector<vector<int>> maze;//迷宫矩阵
vector<vector<int>> path_temp;//存储当前路径，第一维表示位置
vector<vector<int>> path_best;//存储最佳路径void MazeTrack(int i, int j){maze[i][j] = 1;//表示当前节点已走，不可再走path_temp.push_back({ i, j });//将当前节点加入到路径中//判断是否到达终点if (i == N - 1 && j == M - 1){if (path_best.empty() || path_temp.size() < path_best.size()){path_best = path_temp;}}if (i - 1 >= 0 && maze[i - 1][j] == 0)//探索向上走是否可行MazeTrack(i - 1, j);if (i + 1 < N && maze[i + 1][j] == 0)//探索向下走是否可行MazeTrack(i + 1, j);if (j - 1 >= 0 && maze[i][j - 1] == 0)//探索向左走是否可行MazeTrack(i, j - 1);if (j + 1 < M && maze[i][j + 1] == 0)//探索向右走是否可行MazeTrack(i, j + 1);maze[i][j] = 0;         //恢复现场，设为未走path_temp.pop_back();
}int main(){while (cin >> N >> M){maze = vector<vector<int>>(N, vector<int>(M, 0));path_temp.clear();path_best.clear();for (auto &i : maze){for (auto &j : i){cin >> j;}}//回溯寻找迷宫最短通路MazeTrack(0, 0);for (auto i : path_best){cout << '(' << i[0] << ',' << i[1] << ')' << endl;}}return 0;
}

编程题3：星际战争

NowCoder终于破译了外星人的密码！他们的密码是一串整数，通过一张表里的信息映射成最终4位密码。表的规则是：n对应的值是矩阵X的n次方的左上角，如果这个数不足4位则用0填充，如果大于4位的则只输出最后4位

|1 1|^n    |Xn ..|
|1 0|      |.. ..|

例如n=2时，

|1 1|^2 => |1 1| * |1 1| => |2 1|
|1 0|      |1 0|   |1 0|    |1 1|

即2对应的数是“0002”

输入描述:输入有多组数据
每组数据两行：第一行包含一个整数 n ；第二行包含n个正整数Xi

输出描述:对应每一组输入，输出一行相应的密码

其实题目看起来很难，但是计算过几次，就可以发现左上角的数字按照 1 2 3 5 8 …这样的数列规则依次递增，所以本质是一个斐波那契数列

printf 函数中可以按照题目要求的格式输出数字
printf("%04d", FeiBoNa(a[i])%10000); 如果数字的个数小于4，则前面自动补0，否则正常输出.

#include <iostream>
#include <vector>
using namespace std;int FeiBoNa(int n) {if (n == 0) {return 0;}if (n == 1) {return 1;}if (n == 2) {return 2;}return FeiBoNa(n - 1) + FeiBoNa(n - 2);
}int main() {int n;vector<int>a;while (cin >> n) {a.resize(n);for (int i = 0; i < n; ++i) {cin >> a[i];printf("%04d", FeiBoNa(a[i])%10000);}}return 0;
}

但是如果数目太大，递归所使用的时间太长了，那就得使用循环了

#include <iostream>
#include <vector>
std::vector<int> a = { 1,1 };
void data_init(){int i;for (i = 2; i < 10005; i++) {a.push_back((a[i - 1] + a[i - 2]) % 10000);}
}int main(){int n, t;data_init();while (std::cin >> n) {while (n--) {std::cin >> t;printf("%04d", a[t]);}printf("\n");}return 0;
}

先把数组初始化好，然后直接调用就可以了

还可以把递归转变为迭代式的循环方式

#include <iostream>
using namespace std;int datacal(int num) {int first = 1;int second = 2;int third = 0;while (--num) {third = first + second;first = second;second = third;}return first;
}int main(){int n, t;while (std::cin >> n) {while (n--) {std::cin >> t;printf("%04d", datacal(t)%10000);}printf("\n");}return 0;
}

编程题4：树根

数根可以通过把一个数的各个位上的数字加起来得到。如果得到的数是一位数，那么这个数就是数根；如果结果是两位数或者包括更多位的数字，那么再把这些数字加起来。

如此进行下去，直到得到是一位数为止。比如，对于24 来说，把2 和4 相加得到6，由于6 是一位数，因此6 是24 的数根。再比如39，把3 和9 加起来得到12，由于12 不是一位数，因此还得把1 和2 加起来，最后得到3，这是一个一位数，因此3 是39 的数根。现在给你一个正整数，输出它的数根。

输入描述：输入包含多组数据，每组数据数据包含一个正整数 n

输出描述：对应每一组数据，输出该正整数的数根

例输入：24 39
输出：6 3

int numRoot(int num) {int nroot = 0;while (num > 0) {nroot += num % 10;num /= 10;}//下面这个条件特别容易写错为if,一定要是while，//因为这个是递归，return 返回的时候并不一定会退出，只是返回到//上一层函数的调用的末尾while (nroot > 9) {nroot = numRoot(nroot);}return nroot;
}int main(){std::string origin;while (std::cin >> origin) {int sum = 0;//先将每一位进行相加得到总和，防止数字过大//如果数组过大，会浪费大量的时间去计算每一位的数字//所以在这里做一个简单的优化for (int i = 0; i < origin.length(); i++) {sum += origin[i] - '0';}//对总和求树根std::cout << numRoot(sum) << std::endl;}return 0;
}

LRU算法，走迷宫，数根，星际战争相关推荐

刷题日记【第十三篇】-笔试必刷题【数根+星际密码+跳台阶扩展问题+快到碗里来】
刷题日记[第十三篇]-笔试必刷题[数根+星际密码+跳台阶扩展问题+快到碗里来] 1.方法区在JVM中也是一个非常重要的区域,它与堆一样,是被[线程共享]的区域. 下面有关JVM内存,说法错误的是?(c ...
c语言bfs算法走迷宫,使用广度优先算法(BFS)走迷宫
前面介绍广度优先算法的时候提及了多次走迷宫,我们就真正的走一次迷宫试试! 要求如下: 输入给出迷宫矩阵的行数和列数,并给出迷宫(使用点 (.) 表示路,使用星 (*) 表示障碍物,使用S表示起点,T表 ...
DFS算法走迷宫（python实现）
从@走到!31*31的迷宫 map = [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...
《啊哈算法》解救小哈（深度优先算法——走迷宫实战） P86
#include <stdio.h>int n, m, p, q, min=999999; //n和m分别为行和列, p和q分别为终点的x,y坐标, min是最小步数 int a[51][ ...
基于深度优先算法和A*算法的迷宫游戏开发（Java实现）
先上图文章目录一.实验内容二.深度优先算法生成迷宫三.A*算法走迷宫四.结果测试五.源代码六.参考文献一.实验内容 1.要求: 1)迷宫随机生成 2)系统用A*算法寻路,输出路径 3) ...
每日一练2425——年终奖迷宫问题（难）星际密码（易错）数根（接收数据的方法）
文章目录年终奖思路: 代码: 迷宫问题思路: 代码: 星际密码思路: 代码: 数根思路: 代码: 年终奖题目链接: 思路: 本题需要使用动态规划求解. 定义f(i,j)表示从左上角走到坐标 ...
刷题笔记之十一 (计算字符串的编辑距离+微信红包+年终奖+迷宫问题+星际密码+数根)
目录 1. 计算字符串的编辑距离 2. 微信红包 3. 双向链表修改,比如插入新的结点,一定要画图 4. 一颗完全二叉树第六层有9个叶结点(根为第一层),则结点个数最多有109 5. 将N条长度均为M ...
【算法刷题日记之本手篇】星际密码与数根
⭐️前面的话⭐️ 本篇文章介绍来自牛客试题广场的两道题题解,分别为[星际密码]和[数根],展示语言java. 小贴士:本专栏所有题目来自牛客->面试刷题必用工具
JAVA算法：走迷宫回溯算法设计（JAVA版本）
JAVA算法:走迷宫回溯算法设计(JAVA版本) 迷宫数组 int[][] maze = { {0, 1, 0, 0, 0}, {0, ...

LRU算法，走迷宫，数根，星际战争

问答题1

编程题

LRU算法，走迷宫，数根，星际战争相关推荐

最新文章

热门文章