每日一练2023.4.17-2023.4.18
数轴上的bfs
农夫约翰被通知，他的一只奶牛逃逸了！所以他决定，马上出发，尽快把那只奶牛抓回来．
他们都站在数轴上．约翰在N(0≤N≤100000)处，奶牛在K(0≤K≤100000)处．约翰有
两种办法移动，步行和瞬移：步行每秒种可以让约翰从x处走到x+1或x-1处；而瞬移则可让他在1秒内从x处消失，在2x处出现．然而那只逃逸的奶牛，悲剧地没有发现自己的处境多么糟糕，正站在那儿一动不动．
那么，约翰需要多少时间抓住那只牛呢？
输入格式
* Line 1: Two space-separated integers: N and K
仅有两个整数N和K.
输出格式
* Line 1: The least amount of time, in minutes, it takes for Farmer John to catch the fugitive cow.
最短的时间．
样例
输入样例：
5 17
Farmer John starts at point 5 and the fugitive cow is at point 17.
输出样例：
4
OUTPUT DETAILS:
The fastest way for Farmer John to reach the fugitive cow is to
move along the following path: 5-10-9-18-17, which takes 4 minutes.
广搜 - -队列
每次取队头元素出队列，对于该队头节点，可能就是要求的节点，成功，退出；也可能不是，不是的话，利用该队头元素扩展与该节点有边相连且没有被访问的节点，将新的节点入队 ，直到队为空，所有图中相连的节点都被访问过。
使用队列：
手写队列，队列有两个指针-front和rear，对于这两个指针，操作都是+1就是上移，如果需要构造循环队列，则需要进行取余对队列长度queueLength进行操作，队列为空等价于front不等于rear，即队首队尾指针不同，稍微整理代码如下，
///普通队列
#define MAXLENGTH 100000
int que[MAXLENGTH + 50];
int rear = 0;
int front = 0;
while (rear != front){
que[rear] = 入队元素值;
rear++;
//出队
front = front + 1;
}
进行循环队列
#define MAXLENGTH 100000
int que[MAXLENGTH];
int rear = 0;
int front = 0;
while (rear != front){
que[rear] = 入队元素值;
rear=(rear+1)%MAXLENGTH;
//出队
front = (front + 1)%MAXLENGTH;
}参考代码：
#include
#define MAXLENGTH 100000
int que[MAXLENGTH + 50];
int flag[MAXLENGTH + 50];
int main() {
//int dp[MAXLENGTH+50];
int rear = 0;
int front = 0;
int s, t;
scanf("%d %d", &s, &t);
que[0] = s;
//front=(front+1)%(MAXLENGTH+50);
rear = rear + 1;
flag[s] = 1;
int i = s;
int cnt = 0;
while (rear != front) {
if (flag[t] == 1) {
printf("%d\n", cnt);
return 0;
}
cnt++;//步数加一
int loopf = front;
int loopr = rear;
for (int j = loopf; j != loopr; j++)
{
int tt = que[j];
//在范围内且没有走过
if (tt * 2 <= MAXLENGTH && flag[tt * 2] == 0) {
que[rear] = tt * 2;
flag[tt * 2] = 1;rear++;
}
if (tt + 1 <= MAXLENGTH && flag[tt + 1] == 0) {
que[rear] = tt + 1;
flag[tt + 1] = 1;rear++;
}
if (tt - 1 >= 0 && flag[tt - 1] == 0) {
que[rear] = tt - 1;
flag[tt - 1] = 1;rear++;
}
front = front + 1;
}
}
return 0;
} 如果不仅要输出所需时间，还需要输出路径，如何编程实现
设置每个点的前驱并进行记录
/*
Time Limit: 1000 ms
Memory Limit: 256 mb
农夫John的奶牛跑路了。将地图视作一条数轴，
John的初始位置在s而奶牛的位置在t(0<=s,t<=100000)。John可以花费一分钟的时间使自己作如下移动：
1 从点x移动到点x+1
2 从点x移动到点x-1
3 从点x移动到点x*2
奶牛的位置一直在点t。现在给定s,t，要求John要追上奶牛最少需要几分钟。
*/
#include
#define MAXLENGTH 100000//设置最大的数
int que[MAXLENGTH + 50];//记录队列，用于bfs广度优先搜索
int flag[MAXLENGTH + 50];//记录是否走过，1表示走过，0表示未走过
int mapp[MAXLENGTH + 50];//记录前驱
int pathp[MAXLENGTH + 50];//记录路径，用于输出路径
int main() {
//队尾指针
int rear = 0;
//队首指针
int front = 0;
int s, t;
scanf("%d %d", &s, &t);
que[0] = s;//起点入队
//front=(front+1)%(MAXLENGTH+50);
rear = rear + 1;//尾指针移动
flag[s] = 1;//标记，该点已走过
int cnt = 0;//计数，当前所走时间
while (rear != front) {
if (flag[t] == 1) {
//到达终点，输出时间和路径
//输出时间
printf("%d\n", cnt);
//路径转换--记录是前驱，需要先得到路径再逆序输出
int tmp;
tmp = t;
//printf("%d<-", tmp);
int itmp = 0;
pathp[itmp] = tmp;
itmp++;
while (1) {
if (mapp[tmp] == s)
{
//printf("%d", mapp[tmp]);
pathp[itmp] = mapp[tmp];
//itmp++;
break;
}
else {
//printf("%d<-", mapp[tmp]);
pathp[itmp] = mapp[tmp];
itmp++;
tmp= mapp[tmp];
}
}
//输出起点
printf("%d", pathp[itmp]);//print s
//输出路径，直到终点
for (int j = itmp-1; j >= 0; j--) {
printf("->%d", pathp[j]);//print s
}
return 0;
}
cnt++;//步数加一
//记录当前队列队首队尾指针
int loopf = front;
int loopr = rear;
//当前队列数据出队并压入新的数据
for (int j = loopf; j != loopr; j++)
{
int tt = que[j];
//在范围内且没有走过
if (tt - 1 >= 0 && flag[tt - 1] == 0) {
que[rear] = tt - 1;//入队
flag[tt - 1] = 1;//标记
mapp[tt - 1] = tt;//前驱
rear++;//入队
}
if (tt * 2 <= MAXLENGTH && flag[tt * 2] == 0) {
que[rear] = tt * 2;//入队
flag[tt * 2] = 1;//标记
mapp[tt * 2] = tt;//前驱
rear++;//入队
}
if (tt + 1 <= MAXLENGTH && flag[tt + 1] == 0) {
que[rear] = tt + 1;//入队
flag[tt + 1] = 1;//标记
mapp[tt + 1] = tt;//前驱
rear++;//入队
}
front = front + 1;//出队
}
}
return 0;
} 二维平面上的bfs
定义一个二维数组：
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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。
输入：一个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)
提示：
在一个点访问完后，并且拓展出其周围全部的点后，并不能就丢弃，
而是应该储存起来；
然后通过下标，回溯寻找出路径。
输出路径，可以参考链表或者迪杰斯特拉算法等，对于一个点，设置其前继，即该点前面的点，由此可以得到路径。
#include
int maze[10][10];
struct point {
int x;
int y;
};
struct point que[100];
int flag[10][10];//记录是否走过
struct point mapp[10][10];//记录(i,j)的前驱
struct point path[100];//记录路径用于输出
int main() {
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++) {
scanf("%d,", &maze[i][j]);
}
int front = 0;
int rear = 0;
que[0].x = 0;//入队
que[0].y = 0;
rear++;
flag[0][0] = 1;//左上角点标记
int cnt = 0;
while (1) {
if (flag[4][4] == 1) {//到达终点
printf("路径长度是%d\n", cnt);
//路径转换并输出
int pathcnt = 0;
//path[0].x = 4;
//path[0].y = 4;
//pathcnt++;
struct point pointtmp;
pointtmp.x = 4;
pointtmp.y = 4;
while (1) {
int tmppathx = pointtmp.x;
int tmppathy = pointtmp.y;
if (tmppathx == 0 && tmppathy == 0) {
//到达起点
path[pathcnt].x = 0;
path[pathcnt].y = 0;
break;
}
else {//迭代
path[pathcnt].x = tmppathx;
path[pathcnt].y = tmppathy;
pathcnt++;//下标加一
pointtmp.x = mapp[tmppathx][tmppathy].x;
pointtmp.y = mapp[tmppathx][tmppathy].y;
}
}
//输出起点
for (int printi = pathcnt; printi >= 0; printi--) {
printf("(%d,%d)\n", path[printi].x, path[printi].y);
}
break;
}
cnt++;
int rear_ = rear;
int front_ = front;
for (int i = front_; i != rear_; i++) {
//寻找可能入队的
int xtmp = que[i].x;
int ytmp = que[i].y;
int next[4][2] = { 1,0,0,1,-1,0,0,-1
};
for (int nexti = 0; nexti < 4; nexti++) {
int nextx = xtmp + next[nexti][0];
int nexty = ytmp + next[nexti][1];
if (nextx < 5 && nexty < 5 && nextx >= 0 && nexty >= 0 && maze[nextx][nexty] == 0 && flag[nextx][nexty] == 0) {
que[rear].x = nextx;//入队
que[rear].y = nexty;
rear++;
flag[nextx][nexty] = 1;//标记
mapp[nextx][nexty].x = xtmp;//记录前驱
mapp[nextx][nexty].y = ytmp;
}
}
front++;//出队
}
}
return 0;
} bfs
如图所示： 有9只盘子，排成1个圆圈。其中8只盘子内装着8只蚱蜢，有一个是空盘。
我们把这些蚱蜢顺时针编号为 1~8。每只蚱蜢都可以跳到相邻的空盘中，也可以再用点力，越过一个相邻的蚱蜢跳到空盘中。
请你计算一下，如果要使得蚱蜢们的队形改为按照逆时针排列，并且保持空盘的位置不变（也就是1-8换位，2-7换位,...），至少要经过多少次跳跃？
思路：多动不如一动，考虑空盘子在动，
盘子的状态使用数字表示，数字有很多，9*8*7*6*5*4*3*2*1种排列情况，但是使用数字直接表示需要更多的数据内存，会报错，使用map完成映射，缩小数组元素个数；其余就是bfs常规部分，代码如下，
#include
#include