图论之dfs与bfs的练习

news2025/1/18 16:51:14

dfs--深度优选搜索

bfs--广度优先搜索

迷宫问题--dfs

问题:

给定一个n*m的二维迷宫数组其中S是起点,T是终点,*是墙壁(无法通过), .是道路
问从起点S出发沿着上下左右四个方向走,能否走到T点?能输出"YES",否则输出"NO"。


8 8


*****...
*.S...**
*****.**
*****..*
*T..**.*
.**.**.*
..*....*
...*****

#include<iostream>
using namespace std;
const int N = 1e4 + 10;
char g[N][N];//迷宫数组
bool vis[N][N];//二维标记数组
//方向数组
int dx[] = { 0,0,-1,1 };
int dy[] = { 1,-1,0,0 };
int n, m;
int sx, sy, tx, ty;
bool flag;
void dfs(int px, int py) {
	//如果当前搜的点p是终点点t,终止搜索
	if (px == tx && py == ty) {
		flag = true;
		return;
	}
	//沿着点p的邻接点继续搜索
	for (int i = 0; i < 4; i++) {
		int bx=px+dx[i], by=py+dy[i];//生成邻接点
		if (bx<1 || bx>n || by<1 || by>m) continue;//迷宫图的边界
		if (g[bx][by] == '*') continue;//墙壁
		if (vis[bx][by]) continue;//走过的不再走
		vis[bx][by] = 1;
		dfs(bx, by);
	
	}
}
int main() {
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			cin >> g[i][j];
			if (g[i][j] == 'S') sx = i, sy = j;//找到起点的坐标
			if (g[i][j] == 'T') tx = i, ty = j;//找到终点的坐标
		}
	}
	vis[sx][sy] = 1;
	flag = false;
	dfs(sx, sy);
	if (flag) cout << "YES" << endl;
	else cout << "NO" << endl;
	return 0;
}

求迷宫问题的最短路--bfs

问题:

给定一个n*m的二维迷宫数组其中S是起点,T是终点,*是墙壁(无法通过), .是道路
问从起点S出发沿着上下左右四个方向走,能否走到T点?如果能打印最短路径长度,否则输出0。


8 8


*****...
*.S...**
*****.**
*****..*
*T..**.*
.**.**.*
..*....*
...*****

#include<iostream>
#include<queue>
using namespace std;
const int N = 1e4 + 10;
char g[N][N];//迷宫数组
bool vis[N][N];//二维标记数组
//方向数组
int dx[] = { 0,0,-1,1 };
int dy[] = { 1,-1,0,0 };
int n, m;
int sx, sy, tx, ty;
struct point {
	int x, y, depth;
};
void bfs(point s) {
	queue<point> q;
	q.push(s);   vis[s.x][s.y] = 1;

	while (!q.empty()) {
		point cur = q.front();  q.pop();
		if (cur.x == tx && cur.y == ty) {
			flag = true;
			cout << cur.depth - 1 << endl;
			return;
		}
		//通过方向数组找到cur的邻接点,沿着邻接点继续广搜
		for (int i = 0; i < 4; i++) {
			int bx = cur.x + dx[i], by = cur.y + dy[i];//生成邻接点
			if (bx<1 || bx>n || by<1 || by>m) continue;
			if (g[bx][by] == '*') continue;
			if (vis[bx][by]) continue;
			vis[bx][by] = 1;
			q.push({ bx,by,cur.depth + 1 });
		}
	}
}
int main() {
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			cin >> g[i][j];
			if (g[i][j] == 'S') sx = i, sy = j;
			if (g[i][j] == 'T') tx = i, ty = j;
		}
	}
	vis[sx][sy] = 1;
	flag = false;
	bfs({ sx, sy ,1});
	return 0;
}

1215:迷宫

 

信息学奥赛一本通(C++版)在线评测系统

【题目描述】

一天Extense在森林里探险的时候不小心走入了一个迷宫,迷宫可以看成是由n×n�×�的格点组成,每个格点只有22种状态,.#,前者表示可以通行后者表示不能通行。同时当Extense处在某个格点时,他只能移动到东南西北(或者说上下左右)四个方向之一的相邻格点上,Extense想要从点A走到点B,问在不走出迷宫的情况下能不能办到。如果起点或者终点有一个不能通行(为#),则看成无法办到。

【输入】

第1行是测试数据的组数k�,后面跟着k�组输入。每组测试数据的第11行是一个正整数n(1≤n≤100)�(1≤�≤100),表示迷宫的规模是n×n�×�的。接下来是一个n×n�×�的矩阵,矩阵中的元素为.或者#。再接下来一行是44个整数ha,la,hb,lbℎ�,��,ℎ�,��,描述A处在第haℎ�行, 第la��列,B处在第hbℎ�行, 第lb��列。注意到ha,la,hb,lbℎ�,��,ℎ�,��全部是从00开始计数的。

【输出】

k�行,每行输出对应一个输入。能办到则输出“YES”,否则输出“NO”。

【输入样例】

2
3
.##
..#
#..
0 0 2 2
5
.....
###.#
..#..
###..
...#.
0 0 4 0

【输出样例】

YES
NO
解法一:dfs
#include<iostream>
using namespace std;
const int N = 1e2 + 10;
char g[N][N];//迷宫数组
bool vis[N][N];//标记数组
int t,n, sx, sy, tx, ty;
//方向数组
int dx[] = { 0,0,1,-1 };
int dy[] = { 1,-1,0,0 };
bool flag;
void dfs(int px, int py) {
	if (px == tx && py == ty) {
		flag = true;
		return;
	}
	//沿着邻接点继续搜索
	for (int i = 0; i < 4; i++) {
		int bx = px + dx[i], by = py + dy[i];
		if (bx<1 || bx>n || by<1 || by>n) continue;
		if (g[bx][by] == '#') continue;
		if (vis[bx][by]) continue;
		//如果以上情况均不成立,证明邻接点有效,沿着该邻接点继续深搜
		vis[bx][by] = 1;//不标记会报栈溢出错误
		dfs(bx, by);
	}
}
int main() {
	cin >> t;
	while (t--) {
		cin >> n;
		for (int i = 1; i <= n; i++)
			for (int j = 1; j <= n; j++)
				cin >> g[i][j];  
		cin >> sx >> sy >> tx >> ty;
		sx++, sy++, tx++, ty++;//注意:本题下标从0开始
		//多组数据要将相关状态重置
		flag = false;
		memset(vis, 0, sizeof vis);//将vis数组全体清0
		vis[sx][sy] = 1;
		dfs(sx, sy);
		if (flag) cout << "YES" << endl;
		else cout << "NO" << endl;
	}
	return 0;
}
 解法二:bfs
#include<iostream>
#include<queue>
using namespace std;
const int N = 1e2 + 10;
char g[N][N];//迷宫数组
bool vis[N][N];//标记数组
int t, n, sx, sy, tx, ty;
//方向数组
int dx[] = { 0,0,1,-1 };
int dy[] = { 1,-1,0,0 };
bool flag;
struct point {
	int x, y;
};
void bfs(point p) {
	queue<point> q;
	q.push(p);  vis[p.x][p.y] = 1;

	while (!q.empty()) {
		point cur=q.front();  q.pop();
		if (cur.x == tx && cur.y== ty) {
			flag = true;
			return;
		}
		//沿着邻接点继续搜索
		for (int i = 0; i < 4; i++) {
			int bx = cur.x + dx[i], by = cur.y + dy[i];
			if (bx<1 || bx>n || by<1 || by>n) continue;
			if (g[bx][by] == '#') continue;
			if (vis[bx][by]) continue;
			//如果以上情况均不成立,证明邻接点有效,沿着该邻接点继续深搜
			vis[bx][by] = 1;
			q.push({ bx,by });
		}
	}
}
int main() {
	cin >> t;
	while (t--) {
		cin >> n;
		for (int i = 1; i <= n; i++)
			for (int j = 1; j <= n; j++)
				cin >> g[i][j];   /*scanf(" %c", &g[i][j]); */
		cin >> sx >> sy >> tx >> ty;
		sx++, sy++, tx++, ty++;//注意本题下标从0开始
		//多组数据要将相关状态重置
		flag = false;
		memset(vis, 0, sizeof vis);//将vis数组全体清0
		vis[sx][sy] = 1;
		bfs({sx, sy});
		if (flag) cout << "YES" << endl;
		else cout << "NO" << endl;
	}
	return 0;
}

1216:红与黑

【题目描述】

有一间长方形的房子,地上铺了红色、黑色两种颜色的正方形瓷砖。你站在其中一块黑色的瓷砖上,只能向相邻的黑色瓷砖移动。请写一个程序,计算你总共能够到达多少块黑色的瓷砖。

【输入】

包括多组数据。每组数据的第一行是两个整数W和H,分别表示x方向和y方向瓷砖的数量。W和H都不超过20。在接下来的H行中,每行包括W个字符。每个字符表示一块瓷砖的颜色,规则如下:

1)‘.’:黑色的瓷砖;

2)‘#’:红色的瓷砖;

3)‘@’:黑色的瓷砖,并且你站在这块瓷砖上。该字符在每组数据中唯一出现一次。

当在一行中读入的是两个零时,表示输入结束。

【输出】

对每组数据,分别输出一行,显示你从初始位置出发能到达的瓷砖数(记数时包括初始位置的瓷砖)。

【输入样例】

6 9 
....#.
.....#
......
......
......
......
......
#@...#
.#..#.
0 0

【输出样例】

45
解法一:dfs
#include<iostream>
using namespace std;
const int N = 1e2 + 10;
char g[N][N];//迷宫数组
bool vis[N][N];//二维标记数组
//方向数组
int dx[] = { 0,0,-1,1 };
int dy[] = { 1,-1,0,0 };
int sx, sy;
int w, h;
int cnt;
void dfs(int px,int py)
{
	//沿着邻接点搜索
	for (int i = 0; i < 4; i++)
	{
		int bx = px + dx[i], by = py + dy[i];
		if (g[bx][by] == '#')continue;
		if (bx<1 || bx>w || by<1 || by>h)continue;
		if (vis[bx][by])continue;
		vis[bx][by] = 1;
		cnt++;
		dfs(bx, by);
	}
}

int main()
{
	/*注意:本题是先输入列再输入行*/
	while (cin >> h >> w && w && h)//注意要判断w和h都为0结束
	{
		for (int i = 1; i <= w; i++)
		{
			for (int j = 1; j <= h; j++)
			{
				cin >> g[i][j];
				if (g[i][j] == '@')
					sx = i, sy = j;
			}

		}
		//多组数据注意相关状态
		cnt = 1;
		memset(vis, 0, sizeof vis);//vis数组全体清0
		vis[sx][sy] = 1;
		dfs(sx, sy);
		cout << cnt << endl;
	}
	
	return 0;
}
 解法二:bfs
#include<iostream>
#include<queue>
using namespace std;
const int N = 1e2 + 10;
char g[N][N];//迷宫数组
bool vis[N][N];//二维标记数组
//方向数组
int dx[] = { 0,0,-1,1 };
int dy[] = { 1,-1,0,0 };
int sx, sy;
int w, h;
int cnt;
struct point
{
	int x, y;
};
void dfs(point s)
{
	queue<point>q;
	q.push(s); vis[s.x][s.y] = 1;
	while (!q.empty()) 
	{
		point cur = q.front(); q.pop();
		//沿着邻接点搜索
		for (int i = 0; i < 4; i++)
		{
			int bx = cur.x + dx[i], by = cur.y + dy[i];
			if (g[bx][by] == '#')continue;
			if (bx<1 || bx>w || by<1 || by>h)continue;
			if (vis[bx][by])continue;
			vis[bx][by] = 1;
			cnt++;
			q.push({bx,by});
		}
	}
}

int main()
{
	/*注意:本题是先输入列再输入行*/
	while (cin >> h >> w && w && h)//注意要判断w和h都为0结束
	{
		for (int i = 1; i <= w; i++)
		{
			for (int j = 1; j <= h; j++)
			{
				cin >> g[i][j];
				if (g[i][j] == '@')
					sx = i, sy = j;
			}

		}
		//多组数据注意相关状态
		cnt = 1;
		memset(vis, 0, sizeof vis);//vis数组全体清0
		vis[sx][sy] = 1;
		dfs({ sx, sy });
		cout << cnt << endl;
	}
	
	return 0;
}

1219:马走日--dfs

注意:本题需要用到回溯算法,故只能用深度优先搜索

【题目描述】

马在中国象棋以日字形规则移动。

请编写一段程序,给定n×m大小的棋盘,以及马的初始位置(x,y),要求不能重复经过棋盘上的同一个点,计算马可以有多少途径遍历棋盘上的所有点。

【输入】

第一行为整数T(T < 10),表示测试数据组数。

每一组测试数据包含一行,为四个整数,分别为棋盘的大小以及初始位置坐标n,m,x,y。(0≤x≤n-1,0≤y≤m-1, m < 10, n < 10)。

【输出】

每组测试数据包含一行,为一个整数,表示马能遍历棋盘的途径总数,0为无法遍历一次。

【输入样例】

1
5 4 0 0

【输出样例】

32
#include<iostream>
using namespace std;
const int N = 1e2 + 10;
int g[N][N];//迷宫数组
bool vis[N][N];//二维标记数组
//方向数组--八个方向
int dx[] = { 1,1,-1,-1,2,2,-2,-2 };
int dy[] = { 2,-2,2,-2,1,-1,1,-1};
int t; int n, m,sx,sy;
int cnt;
void dfs(int px, int py, int depth)
{
	if (depth == n * m)//按照此时的搜索方案已经搜完整个棋盘了
	{
		cnt++;
		return;
	}
	for (int i = 0; i < 8; i++)/*注意:八个方向*/
	{
		int bx = px + dx[i], by = py + dy[i];
		if (vis[bx][by])continue;
		if (bx<1 || bx>n || by<1 || by>m)continue;
		vis[bx][by] = 1;
		dfs(bx, by,depth+1);
		//回溯
		vis[bx][by] = 0;
	}

}
int main()
{
	cin >> t;
	while (t--)
	{
		cin >> n >> m;
		//多组数据相关状态清空
		cnt =0;
		cin >> sx >> sy;
		sx++, sy++;
		memset(vis, 0, sizeof vis);
		vis[sx][sy] = 1;
		dfs(sx, sy,1);//起点是第一层,最后应该走到n*m层结束
		cout << cnt << endl;
	}
	return 0;
}

 1212:LETTERS--dfs

【题目描述】

给出一个row×col���×���的大写字母矩阵,一开始的位置为左上角,你可以向上下左右四个方向移动,并且不能移向曾经经过的字母。问最多可以经过几个字母。

【输入】

第一行,输入字母矩阵行数R�和列数S�,1≤R,S≤201≤�,�≤20。

接着输出R�行S�列字母矩阵。

【输出】

最多能走过的不同字母的个数。

【输入样例】

3 6
HFDFFB
AJHGDH
DGAGEH

【输出样例】

6
#include<iostream>
using namespace std;
char g[N][N];
bool vis[N];
int dx[] = { 1,-1,0,0};
int dy[] = { 0,0,1,-1};
int n, m;
int ans = 0;
void dfs(int px,int py,int depth)
{
	ans = max(ans, depth);//选取经过字母数最多的
	for (int i = 0; i < 4; i++)
	{
		int bx = px + dx[i], by = py + dy[i];
		if (vis[g[bx][by]])continue;
		if (bx<1 || bx>n || by<1 || by>m) continue;
		vis[g[bx][by]] = 1;
		dfs(bx, by, depth + 1);
		vis[g[bx][by]] =0;//回溯
	}
}
int main()
{
	cin >> n >> m;
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= m; j++)
		{
			cin >> g[i][j];
		}
	}
	vis[g[1][1]] = 1;
	dfs(1,1,1);
	cout << ans;
	return 0;
}

求最短路径

1251:仙岛求药--bfs

【题目描述】

少年李逍遥的婶婶病了,王小虎介绍他去一趟仙灵岛,向仙女姐姐要仙丹救婶婶。叛逆但孝顺的李逍遥闯进了仙灵岛,克服了千险万难来到岛的中心,发现仙药摆在了迷阵的深处。迷阵由M×N个方格组成,有的方格内有可以瞬秒李逍遥的怪物,而有的方格内则是安全。现在李逍遥想尽快找到仙药,显然他应避开有怪物的方格,并经过最少的方格,而且那里会有神秘人物等待着他。现在要求你来帮助他实现这个目标。

下图 显示了一个迷阵的样例及李逍遥找到仙药的路线。

【输入】

输入有多组测试数据. 每组测试数据以两个非零整数 M 和 N 开始,两者均不大于20。M 表示迷阵行数, N 表示迷阵列数。接下来有 M 行, 每行包含N个字符,不同字符分别代表不同含义:

1)‘@’:少年李逍遥所在的位置;

2)‘.’:可以安全通行的方格;

3)‘#’:有怪物的方格;

4)‘*’:仙药所在位置。

当在一行中读入的是两个零时,表示输入结束。

【输出】

对于每组测试数据,分别输出一行,该行包含李逍遥找到仙药需要穿过的最少的方格数目(计数包括初始位置的方块)。如果他不可能找到仙药, 则输出 -1。

【输入样例】

8 8
.@##...#
#....#.#
#.#.##..
..#.###.
#.#...#.
..###.#.
...#.*..
.#...###
6 5
.*.#.
.#...
..##.
.....
.#...
....@
9 6

.#..#.
.#.*.#
.####.
..#...
..#...
..#...
..#...
#.@.##
.#..#.
0 0

【输出样例】

10
8
-1

#include<iostream>
#include<queue>
using namespace std;
const int N = 1e2 + 10;
int n, m,sx,sy,tx,ty;
char g[N][N];
bool vis[N][N];
int ans = -1;
int dx[] = { 0,0,1,-1 };
int dy[] = { 1,-1,0,0 };
struct point { int x, y, depth; };
void bfs(point p) {
	queue<point> q;
	q.push(p);  vis[p.x][p.y] = 1;
	while (!q.empty()) {
		point cur = q.front(); q.pop();
		if (cur.x == tx && cur.y == ty) {
			ans= cur.depth - 1;
			return;
		}
		for (int i = 0; i < 4; i++) {
			int bx = cur.x + dx[i], by = cur.y + dy[i];
			if (bx<1 || bx>n || by<1 || by>m) continue;
			if (vis[bx][by]) continue;
			if (g[bx][by] == '#') continue;
			vis[bx][by] = 1;
			q.push({ bx,by,cur.depth + 1 });
		}
	}
}
int main() {
	while (cin >> n >> m && n && m) {
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= m; j++) {
				cin >> g[i][j];
				if (g[i][j] == '@') sx = i, sy = j;
				if (g[i][j] == '*') tx = i, ty = j;
			}
		}
		ans = -1;
		memset(vis, 0, sizeof vis);
		bfs({ sx,sy,1 });
		cout << ans << endl;
	}
	return 0;
}

1330:【例8.3】最少步数--bfs

【题目描述】

在各种棋中,棋子的走法总是一定的,如中国象棋中马走“日”。有一位小学生就想如果马能有两种走法将增加其趣味性,因此,他规定马既能按“日”走,也能如象一样走“田”字。他的同桌平时喜欢下围棋,知道这件事后觉得很有趣,就想试一试,在一个(100×100)的围棋盘上任选两点A、B,A点放上黑子,B点放上白子,代表两匹马。棋子可以按“日”字走,也可以按“田”字走,俩人一个走黑马,一个走白马。谁用最少的步数走到左上角坐标为(1,1)的点时,谁获胜。现在他请你帮忙,给你A、B两点的坐标,想知道两个位置到(1,1)点可能的最少步数。

【输入】

A、B两点的坐标。

【输出】

最少步数。

【输入样例】

12 16
18 10

【输出样例】

8
9
#include<iostream>
#include<queue>
const int N = 1e2 + 10;
char g[N][N];
bool vis[N][N];
int dx[] = {1,1,-1,-1,2,2,-2,-2,2,2,-2,-2};
int dy[] = {2,-2,2,-2,1,-1,1,-1,2,-2,2,-2};
int n, m;
int sx, sy;
int ans;
struct point
{
	int x, y,depth;
};
void bfs(point s)
{
	queue<point>q;
	q.push(s); vis[s.x][s.y] = 1;
	while (!q.empty())
	{
		point cur = q.front(); q.pop();
		if (cur.x == 1 && cur.y == 1)
		{
			ans=cur.depth - 1 ;
			return;
		}
		for (int i = 0; i < 12; i++)
		{
			int bx = cur.x + dx[i], by = cur.y + dy[i];
			if (bx<1 || bx>100 || by<1 || by>100)continue;
			if (vis[bx][by])continue;//注意,搜索时也不能搜0
			vis[bx][by] = 1;
			q.push({ bx, by,cur.depth+1});
		}
	}
}

int main()
{
	int t = 2;
	while (t--)
	{
		ans = 0;
		cin >> sx>>sy;
		memset(vis, 0, sizeof vis);
		bfs({ sx, sy ,1});
		cout << ans<<endl;
	}
	return 0;
}

1255:迷宫问题--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<iostream>
#include<queue>
using namespace std;
const int N = 1e2 + 10;
char g[N][N];
bool vis[N][N];
int dx[] = {0,0,1,-1};
int dy[] = {1,-1,0,0};
struct point
{
	int x, y;
};
point path[N][N];
void bfs(point s)
{
	queue<point>q;
	q.push(s); vis[s.x][s.y] = 1;
	while (!q.empty())
	{
		point cur = q.front(); q.pop();
		if (cur.x == 5 && cur.y == 5)return;
		for (int i = 0; i < 4; i++)
		{
			int bx = cur.x + dx[i], by = cur.y + dy[i];
			if (bx < 1 || bx>5 || by < 1 || by>5)continue;
			if (g[bx][by] == '1')continue;
			if (vis[bx][by])continue;
			vis[bx][by] = 1;
			path[bx][by] = cur;
			q.push({bx, by});
		}
	}
}
void print(int px,int py)
{
	if (px == 0 && py == 0)return;
	print(path[px][py].x, path[px][py].y);
	printf("(%d, %d)\n", px-1, py-1);
}
int main()
{
	for (int i = 1; i <= 5; i++)
		for (int j = 1; j <= 5; j++)
			cin >> g[i][j];
	bfs({1,1});
	print(5,5);
	return 0;
}

1257:Knight Moves

【题目描述】

输入n�代表有个n×n�×�的棋盘,输入开始位置的坐标和结束位置的坐标,问一个骑士朝棋盘的八个方向走马字步,从开始坐标到结束坐标可以经过多少步。

【输入】

首先输入一个n�,表示测试样例的个数。

每个测试样例有三行。

第一行是棋盘的大小L(4≤L≤300)�(4≤�≤300);

第二行和第三行分别表示马的起始位置和目标位置(0..L−1)(0..�−1)。

【输出】

马移动的最小步数,起始位置和目标位置相同时输出00。

【输入样例】

3
8
0 0
7 0
100
0 0
30 50
10
1 1
1 1

【输出样例】

5
28
0
#include<iostream>
#include<queue>
//#include<Windows.h>//动画演示
using namespace std;
const int N = 3e2 + 10;
char g[N][N];
bool vis[N][N];
int dx[] = {1,1,2,2,-1,-1,-2,-2};
int dy[] = {2,-2,1,-1,2,-2,1,-1};
int t;
int n,sx, sy, tx, ty;
int ans;
struct point { int x; int y; int depth; };
void dfs(point s)
{
	queue<point>q;
	q.push(s); vis[s.x][s.y] = 1;
	while (!q.empty())
	{
		point cur = q.front(); q.pop();
		if (cur.x == tx && cur.y == ty)
		{
			ans = cur.depth-1;
			return;
		}
		for (int i = 0; i < 8; i++)
		{
			int bx = cur.x + dx[i], by = cur.y + dy[i];
			if (bx<1 || bx> n || by<1 || by>n) continue;
			if (vis[bx][by]) continue;
			vis[bx][by] = 1;
			
			q.push({ bx, by,cur.depth+1 });
		}
	}
	
}

int main()
{
	cin >> t;
	while (t--)
	{
		cin >> n;
		cin >> sx >> sy >> tx >> ty;
		sx++, sy++,tx++, ty++;
		ans = 0;
		memset(vis, 0, sizeof vis);
		dfs({ sx, sy,1 });
		cout << ans<<endl;
	}
	return 0;
}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1455568.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

python如何模拟登录Github

首先进入github登录页&#xff1a;https://github.com/login 输入账号密码&#xff0c;打开开发者工具&#xff0c;在Network页勾选上Preserve Log&#xff08;显示持续日志&#xff09;&#xff0c;点击登录&#xff0c;查看Session请求&#xff0c;找到其请求的URL与Form Da…

Linux——网络通信TCP通信常用的接口和tcp服务demo

文章目录 TCP通信所需要的套接字socket()bind()listen()acceptconnect() 封装TCP socket TCP通信所需要的套接字 socket() socket()函数主要作用是返回一个描述符&#xff0c;他的作用就是打开一个网络通讯端口&#xff0c;返回的这个描述符其实就可以理解为一个文件描述符&a…

GPT升级信息:能记住用户的喜好和习惯!

OpenAI刚刚宣布了ChatGPT的一项激动人心的更新&#xff01; OpenAI在ChatGPT中新加了记忆功能和用户控制选项&#xff0c;这意味着GPT能够在与用户的互动中记住之前的对话内容&#xff0c;并利用这些信息在后续的交谈中提供更加相关和定制化的回答。 这一功能目前正处于测试阶段…

SpringMVC回顾总结笔记

MVC是一种思想而SpringMVC是具体的实现&#xff08;Ioc和DI的关系&#xff09; 在创建项目的时候勾选的SpringWeb框架就是SpringMVC框架 与浏览器建立连接 默认返回的是一个 view 视图。需要添加ResponseBody说明返回的是json数据。RestController是ControllerResponseBody…

【Java EE初阶十四】网络编程TCP/IP协议(一)

1. 网络编程 通过网络&#xff0c;让两个主机之间能够进行通信->就这样的通信来完成一定的功能&#xff0c;进行网络编程的时候&#xff0c;需要操作系统给咱们提供一组API&#xff0c;通过这些API来完成编程&#xff1b;API可以认为是应用层和传输层之间交互的路径&#xf…

Leetcode刷题笔记题解(C++):120. 三角形最小路径和

思路&#xff1a;动态规划&#xff0c;去生成一个对应的当前节点的最小路径值&#xff0c;对应的关系如下所示 dp[0][0] triangle[0][0] dp[i][0] triangle[i][0]dp[i-1][0] dp[i][i] triangle[i][i]dp[i-1][i] dp[i][j] triangle[i][j]min(dp[i-1][j-1],dp[i-1][j]) …

扫描电子显微镜(SEM)样品制备要求与方法解析

扫描电子显微镜&#xff08;Scanning Electron Microscope&#xff0c;简称SEM&#xff09;是一种强大的分析工具&#xff0c;广泛应用于材料科学、生物学、医学、半导体材料和化学化工等领域。SEM能够提供高分辨率的表面形貌图像&#xff0c;因此样品制备成为获取准确、清晰图…

在 MyBatis 中,可以使用相同的 SQL 映射语句进行批量删除和单个删除。

目录 前端代码&#xff1a; 后端代码&#xff1a; controller service层接口 service接口的实现 mapper层接口 xml sql 效果&#xff1a;&#xff08;点击操作列的删除&#xff0c;可删除一行数据。勾选多个多选框再点击批量删除&#xff0c;可删除多个&#xff09; …

Postman路径修改

默认安装好Postman之后&#xff0c;默认路径在&#xff1a;C:\Users\用户名\AppData\Local\Postman。 修改路径只需要将整个文件夹拷贝到需要移动的位置即可&#xff0c;然后重新创建一个快捷方式。再删除原来路径的文件夹。

访问学者感谢信|人文社科工作者赴北欧访学

编者按&#xff1a;这位访问学者从委托我们申请到获得邀请函只用了一个月时间。为了表达感激之情&#xff0c;其当时就写了这封感谢信&#xff0c;但依据我们的惯例&#xff0c;一般是待申请者出国&#xff0c;一切安排妥当后再发成功案例。所以时至今日&#xff0c;才将该申请…

2942. 查找包含给定字符的单词【简单】

2942. 查找包含给定字符的单词【简单】 题目描述&#xff1a; 给你一个下标从 0 开始的字符串数组 words 和一个字符 x 。 请你返回一个 下标数组 &#xff0c;表示下标在数组中对应的单词包含字符 x 。 注意&#xff1a;返回的数组可以是 任意 顺序 示例 1&#xff1a; 输…

海外大带宽服务器连接失败:原因与解决策略

​随着全球互联网的发展&#xff0c;越来越多的企业和个人选择使用海外大带宽服务器来满足数据传输和业务需求。然而&#xff0c;在实际使用中&#xff0c;有时会出现服务器连接失败的问题。本文将为您分析原因并提供相应的解决策略。 一、海外大带宽服务器连接失败的原因 网络…

Firefox火狐浏览器/Google谷歌浏览器安装免费好用的翻译插件,亲测好用舒服了(附上安装包)

文章目录 1. 为什么选择它&#xff1f;2. 下载安装并体验插件2.1 下载安装包2.2 安装插件2.3 翻译体验 1. 为什么选择它&#xff1f; 最近维基百科项目&#xff0c;由于是国外的网站全是英文&#xff0c;我英语又不好&#xff0c;试了好几个英文翻译插件都没法使用&#xff0c…

elementui 中el-date-picker 选择年后输出的是Wed Jan 01 2025 00:00:00 GMT+0800 (中国标准时间)

文章目录 问题分析 问题 在使用 el-date-picker 做只选择年份的控制器时&#xff0c;出现如下问题&#xff1a;el-date-picker选择年后输出的是Wed Jan 01 2025 00:00:00 GMT0800 (中国标准时间)&#xff0c;输出了两次如下 分析 在 el-date-picker 中&#xff0c;我们使用…

小程序全局变量管理-mobx引入与使用

背景&#xff1a; 对于全局变量操作&#xff0c;如果不规范使用很容易产生意想不到的问题&#xff0c;使用mobx对全局变量进行管理&#xff0c;能够规范代码操作&#xff0c;使程序变得简单高效。 代码使用&#xff1a; 1&#xff09;定义全局变量 import { action, observ…

[力扣 Hot100]Day29 删除链表的倒数第 N 个结点

题目描述 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 出处 思路 两个指针间隔n&#xff0c;一趟遍历解决。 代码 class Solution { public:ListNode* removeNthFromEnd(ListNode* head, int n) {ListNode* phead;ListNode* …

使用Docker Compose搭建Redis哨兵架构

搭建Redis哨兵(sentinel) 之前我们通过深入理解REDIS哨兵原理了解了Redis哨兵(sentinel)的原理&#xff0c;今天我们手动部署一个哨兵架构。要在Docker中搭建Redis哨兵(sentinel)架构&#xff0c;需要Redis的主从实例以及哨兵实例。之前我们已经使用Docker Compose搭建Redis主…

MySQL数据库进阶第二篇(索引,SQL性能分析,使用规则)

文章目录 一、索引概述二、索引结构三、结构 - B-Tree四、结构 - BTree五、结构 - Hash六、索引分类七、索引语法1.案例代码 八、SQL性能分析1.查看SQl执行频率2.慢查询日志3.PROFILES详情4.EXPLAIN执行计划 九、 索引使用规则十、SQL 提示十一、覆盖索引十二、前缀索引十三、单…

Qt的基本操作

文章目录 1. Qt Hello World 程序1.1 通过图形化界面的方式1.2 通过代码的方式实现 2. Qt 的编码问题3. 使用输入框实现hello world4. 使用按钮实现hello world5. Qt 编程注意事项6. 查询文档的方式7. 认识Qt坐标系 1. Qt Hello World 程序 1.1 通过图形化界面的方式 我们先讲…

抖音关键词搜索爬虫,抖音API数据接口,抖音商品详情数据采集

抖音商品API接口抖音关键词搜索抖音直播间小黄车抖店商品数据采集 除了微博&#xff0c;小红书&#xff0c;抖音也是一个巨大的流量池。 除了评论&#xff0c;其实关键词搜索视频是更为常见的一个需求&#xff0c;于是上周末抽空开发了下&#xff0c;完成了 mvp。