DFS + BFS + 洛谷题

已于 2022-03-21 21:10:32 修改
阅读量500 收藏 1
点赞数 2
分类专栏： 数据结构 文章标签： 算法 c++
于 2021-10-09 17:20:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51265528/article/details/120669063
版权

DFS

经典的迷宫问题（ 回溯 问题 ）

在起点处有四个方向，上下左右，

在这里插入图片描述走到终点之后，要再返回，看有没有其他更短的路径。

回溯过程，退回之后，要标记该点的值为没有访问过。

在这里插入图片描述直到找到最短的路径。

左右试探的图解
位置变化
在这里插入图片描述

以下是未经优化的代码。（dfs）

#include <iostream>
#include <unordered_map>
using namespace std;
int p, q;  //终点坐标，（P，q）
int a[100][100]; //1表示空地， 2 表示障碍物
int v[100][100];  //0 默认未访问， 1表示访问
int Min=99999;
void dfs(int x, int y, int step)  //x，y表示当前位置
{
	if (x == p && y == q)
	{
		if (step < Min)
			Min = step;
		return;
	}
	//这里默认顺时针试探，右下左上
	//只往右走
	if (a[x][y + 1] == 1 && v[x][y + 1] == 0)
	{
		v[x][y + 1] = 1;   //走到（x,y+1）这个点，并且做标记，表示走过。
		dfs(x, y + 1, step + 1);   //进入下一步，同样的操作
		v[x][y + 1] = 0;//回退出来，把原来的点标为未走过
	}
	//如果右边堵住了，则往下走
	if (a[x+1][y] == 1 && v[x][y + 1] == 0)
	{
		v[x][y + 1] = 1;
		dfs(x+1, y , step + 1);
		v[x][y + 1] = 0;
	}
	//向左走
	if (a[x ][y-1] == 1 && v[x][y - 1] == 0)
	{
		v[x][y - 1] = 1;
		dfs(x , y-1, step + 1);
		v[x][y - 1] = 0;
	}
	//上
	if (a[x-1][y ] == 1 && v[x - 1][y] == 0)
	{
		v[x - 1][y ] = 1;
		dfs(x - 1, y , step + 1);
		v[x - 1][y ] = 0;
	}
	return;
}

int main()
{
	int startx, starty;
	int n = 0, m=0; //m行，n列
	cin >> m >> n;
	for (int i = 1; i <= m; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			cin >> a[i][j];//1表示空地， 2 表示障碍物
		}
	}
	cin >> startx >> starty >> p >> q;
	v[startx][starty] = 1;
	dfs(startx, starty, 0);

	cout << Min;
	return 0;
}

/*
5 4
1  1 2 1
1  1 1 1
1 1 2 1
1 2 1 1
1 1 1 2
1 1 4 3


*/

其实可以定义一个方向数组
在这里插入图片描述
代码优化之后：

#include <iostream>
#include <unordered_map>
using namespace std;
int p, q;  //终点坐标，（P，q）
int a[100][100]; //1表示空地， 2 表示障碍物
int v[100][100];  //0 默认未访问， 1表示访问
int Min=99999;
//使用方向数组
int dx[4] = { 0,1,0,-1 };   
int dy[4] = { 1,0,-1,0 };

void dfs(int x, int y, int step)  //x，y表示当前位置
{
	if (x == p && y == q)
	{
		if (step < Min)
			Min = step;
		return;
	}
	for (int k = 0; k <= 3; k++)  //有四个方向，所以k有4个取值
	{
		int tx ,ty ;
		tx = x + dx[k];
		ty = y + dy[k];
		if (a[tx][ty] == 1 && v[tx][ty] == 0)  //四个方向，只要没有障碍，且没有走过，就可以继续走
		{
			v[tx][ty] = 1;
			dfs(tx, ty, step + 1);
			v[tx][ty] = 0;
		}
	}
	return;
}

int main()
{
	int startx, starty;
	int n = 0, m=0; //m行，n列
	cin >> m >> n;
	for (int i = 1; i <= m; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			cin >> a[i][j];//1表示空地， 2 表示障碍物
		}
	}
	cin >> startx >> starty >> p >> q;
	v[startx][starty] = 1;
	dfs(startx, starty, 0);
	cout << Min;
	return 0;
}

/*
5 4
1  1 2 1
1  1 1 1
1 1 2 1
1 2 1 1
1 1 1 2
1 1 4 3
*/

BFS

在这里插入图片描述在这里插入图片描述
在这里插入图片描述开始是位置（1，1）走的步数是0，
第二步走到（1，2） 走的步数是1
第二步也可以到（2，1 ） 走的步数是1

（拓展完毕之后可以出队）

在这里插入图片描述
进入两个点(能一步到达的位置)，之后把第一个点出队
在这里插入图片描述
然后往下找，一旦入队所有一步能到达的点，则需要出队一个。
在这里插入图片描述在这里插入图片描述出队前，要保证该点下一步能到达的点入队。
不能拓展的，直接出队即可
关于头文件的使用
在这里插入图片描述（4）empty()

empty()检测是否为空，返回true则为空，返回false则非空，时间复杂度O(1)。

程序代码：

#include<cstdio> 
#include<queue>
using namespace std;
int main(){
	queue<int> q;
	printf("%d\n",q.empty());//先开始没有元素，为空(true)；输出 1 
	for(int i=1;i<=5;i++) {
		q.push(i);		//push(i)用以将i压入队列，因此一次入队 1 2 3 4 5 
	}
	printf("%d\n",q.empty());//压入元素，为非看(false)；输出 0
	return 0; 
}

运行结果：

（5）size()

size()返回queue内元素的个数，时间复杂度为O(1)。

程序代码：

#include<cstdio> 
#include<queue>
using namespace std;
int main(){
	queue<int> q;
	for(int i=1;i<=5;i++) {
		q.push(i);		//push(i)用以将i压入队列，因此一次入队 1 2 3 4 5 
	}
	printf("%d\n",q.size());// 输出队列元素个数 
	return 0; 
}

下面是代码实现

#include <iostream>
#include<queue>
using namespace std;
int p, q;  //终点坐标，（P，q）
int a[100][100]; //1表示空地， 2 表示障碍物
int v[100][100];  //0 默认未访问， 1表示访问

//四个方向
int dx[4] = {0, 1, 0, -1};     //四个方向， 右 下 左 上
int dy[4] = {1, 0, -1, 0};

//需要一个结构体，存该点的位置（x，y）， 并且设置步数。
struct point
{
	int x;
	int y;
	int step;
};

queue<point> r;  //申请队列


/*void dfs(int x, int y, int step)  //x，y表示当前位置
{
	if (x == p && y == q)
	{
		if (step < Min)
			Min = step;
		return;
	}
	for (int k = 0; k <= 3; k++)  //有四个方向，所以k有4个取值
	{
		int tx ,ty ;
		tx = x + dx[k];
		ty = y + dy[k];
		if (a[tx][ty] == 1 && v[tx][ty] == 0)  //四个方向，只要没有障碍，且没有走过，就可以继续走
		{
			v[tx][ty] = 1;
			dfs(tx, ty, step + 1);
			v[tx][ty] = 0;
		}
	}
	return;
}
*/

int main()
{
	int startx=0, starty=0;
	int n = 0, m=0; //m行，n列
	int flag = 0;
	cin >> n >> m;
	for (int i = 1; i <= n; i++)//输入
	{
		for (int j = 1; j <= m; j++)
		{
			cin >> a[i][j];
		}
	}
	cin >> startx >> starty >> p >> q;
	//BFS
	point start;  //起点
	start.x = startx;
	start.y = starty;

	start.step=0;
	r.push(start); //将起点入队
	v[startx][starty] =1 ;  //表示有走过
	while (!r.empty())//在队列不为空的时候
	{
		int x = r.front().x,y= r.front().y; //取队首的元素。
		if (x == p && y == q)
		{
			flag = 1;
			cout << r.front().step;
			break;
		}
		for (int k = 0; k <= 3; k++)
		{
			int tx, ty;
			tx = x + dx[k];
			ty = y + dy[k];
			if (a[tx][ty] == 1 && v[tx][ty] == 0)  //空地，且未访问
			{
				// 入队
				point temp;
				temp.x = tx;
				temp.y = ty;
				temp.step = r.front().step + 1; //   到新的点之后就可以步数多1 
				r.push(temp);
				v[tx][ty] = 1; //入队则已访问，设置为1
			}
		}
		r.pop();//将队首元素出队。
	}

	if (flag == 0)  cout << "no";
	else
		cout << "yes";

	return 0;
}

/*
5 4 
1 1 2 1
1 1 1 1
1 1 2 1
1 2 1 1
1 1 1 2
1 1 4 3
*/

1003 Crashing Balloon

On every June 1st, the Children’s Day, there will be a game named “crashing balloon” on TV. The rule is very simple. On the ground there are 100 labeled balloons, with the numbers 1 to 100. After the referee shouts “Let’s go!” the two players, who each starts with a score of “1”, race to crash the balloons by their feet and, at the same time, multiply their scores by the numbers written on the balloons they crash. After a minute, the little audiences are allowed to take the remaining balloons away, and each contestant reports his\her score, the product of the numbers on the balloons he\she’s crashed. The unofficial winner is the player who announced the highest score.

Inevitably, though, disputes arise, and so the official winner is not determined until the disputes are resolved. The player who claims the lower score is entitled to challenge his\her opponent’s score. The player with the lower score is presumed to have told the truth, because if he\she were to lie about his\her score, he\she would surely come up with a bigger better lie. The challenge is upheld if the player with the higher score has a score that cannot be achieved with balloons not crashed by the challenging player. So, if the challenge is successful, the player claiming the lower score wins.

So, for example, if one player claims 343 points and the other claims 49, then clearly the first player is lying; the only way to score 343 is by crashing balloons labeled 7 and 49, and the only way to score 49 is by crashing a balloon labeled 49. Since each of two scores requires crashing the balloon labeled 49, the one claiming 343 points is presumed to be lying.

On the other hand, if one player claims 162 points and the other claims 81, it is possible for both to be telling the truth (e.g. one crashes balloons 2, 3 and 27, while the other crashes balloon 81), so the challenge would not be upheld.

By the way, if the challenger made a mistake on calculating his/her score, then the challenge would not be upheld. For example, if one player claims 10001 points and the other claims 10003, then clearly none of them are telling the truth. In this case, the challenge would not be upheld.

Unfortunately, anyone who is willing to referee a game of crashing balloon is likely to get over-excited in the hot atmosphere that he\she could not reasonably be expected to perform the intricate calculations that refereeing requires. Hence the need for you, sober programmer, to provide a software solution.

Input
Pairs of unequal, positive numbers, with each pair on a single line, that are claimed scores from a game of crashing balloon.
Output
Numbers, one to a line, that are the winning scores, assuming that the player with the lower score always challenges the outcome.
Sample Input
343 49
3599 610
62 36

Sample Output
49
610
62

#include <stdio.h>
int flagA,flagB;
int result ;
void dfs(int m,int n,int kk)    //运用了深度优先的搜索策略
{
    int k =kk;
    if(m==1 && n==1)    
    {
       flagA=1; 
       return ;
    }
    if(n==1)
    flagB =1;   
    while( (k <  m || k <  n) && (k< 100) )
    {
       k++;
       if(m%k==0)
       {
            dfs(m/k,n,k);
            if(flagA)
                return;
       }
       if(n%k==0 )
       {
            dfs(m,n/k,k);
            if(flagA)
            return;
       }
    }
}

int main()
{
    int A,B,t;
    while(scanf("%d%d",&A,&B)!=EOF) 
    {
    	if(A<B)
    	{
    		t=A;
    		A=B;
    		B=t;
		}
		flagA=0;
		flagB=0;
		dfs(A,B,1);
		result=A;
		if(flagA==0 && flagB==1)
		{
			result=B;
		}
		printf("%d\n",result);
	}
    return 0;
}

P1363 幻象迷宫

在这里插入图片描述在这里插入图片描述

这里数据量注意最大是1500 开数组的时候1501也够了

思路： 找到初始地图的某点，存在无限大地图中的一点求模后和该点一致，说明能从该点出发又回到该点，则此时表明它 可以走无限远。所以关键是判断能不能第二次经过该点。

这里用dfs来做

代码如下：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
//只要能访问第二遍，则走无穷远
const int MAXN = 1500 + 1;
const int dx[4] = {1, -1, 0, 0};
const int dy[4] = {0, 0, 1, -1};

int n, m;
int st_x, st_y;
int vis[MAXN][MAXN][3];
bool fl, a[MAXN][MAXN];
char ch;

void dfs(int x, int y, int lx, int ly) {
	if(fl) return;
	if(vis[x][y][0] && (vis[x][y][1]!=lx || vis[x][y][2]!=ly)) //未访问过的，且第二遍经过则成立
	{
		fl = 1;
		return;
	}
	vis[x][y][1] = lx, vis[x][y][2] = ly, vis[x][y][0] = 1;//记录下第一遍的访问点的下标 
	for(int i=0; i<4; ++i) {
		int xx = (x + dx[i] + n) % n, yy = (y + dy[i] + m) % m;//保证不会数组越界 
		int lxx = lx + dx[i], lyy = ly + dy[i];
		if(!a[xx][yy])  //有路可走 
		 {
			if(vis[xx][yy][1]!=lxx || vis[xx][yy][2]!=lyy || !vis[xx][yy][0])
			//(xx,yy)必须是没访问过的结点。 !vis[xx][yy][0]指的是不能重复走这个地图的点，需要走到扩展其他地图上 
				dfs(xx, yy, lxx, lyy);
		}
	}
}
int main() {
	ios::sync_with_stdio(false);
	while(cin >> n >> m) {
		fl = 0;
		memset(a, 0, sizeof(a));
		memset(vis, 0, sizeof(vis));
		for(int i=0; i<n; ++i)
			for(int j=0; j<m; ++j) {
				cin >> ch;
				if(ch == '#') a[i][j] = 1;
				if(ch == 'S') st_x = i, st_y = j;
			}
		dfs(st_x, st_y, st_x, st_y);
		if(fl) puts("Yes");
		else puts("No");
	}
}
smile_keep looking
关注
专栏目录
【算法分析与设计】DFS与BFS的区别
付费专栏已不再维护，请勿购买
03-23 1219
以自己的感悟，浅谈DFS与BFS的区别
洛谷题集——01迷宫（dfs、bfs）
Zhengyangxinn的博客
05-11 723
有一个仅由数字0与1组成的n×n格迷宫。若你位于一格0上，那么你可以移动到相邻4格中的某一格1上，同样若你位于一格1上，那么你可以移动到相邻4格中的某一格0上。 你的任务是：对于给定的迷宫，询问从某一格开始能移动到多少个格子（包含自身）。
广度优先搜索BFS（洛谷）
越看越喜欢啊
11-04 1057
P1162 填涂颜色 P1032 字串变换 P1141 01迷宫 P1126 机器人搬重物 P1443 马的遍历
【BFS】魔鬼之城
LCWLH
05-23 1274
【问题描述】 在一个被分割为N*M个正方形房间的矩形魔鬼之城中，一个探险者必须遵循下列规则才能跳跃行动。他必须从(1, 1)进入，从(N, M)走出；在每一房间的墙壁上都写了一个魔法数字，是1～13之内的自然数；探险者可以想像出8个方向中的任何一个(水平或垂直或对角线方向)，随后他就可以作一次空间跳跃穿过这一方向上的连续的X个房间，其中X是他原来所在房间的魔法数字。但如果在这一方向上的房间数小于X
经典算法研究系列：四、教你通透彻底理解：BFS和DFS优先搜索算法
dinongxu8804的博客
01-01 350
4、教你通透彻底理解：BFS和DFS优先搜索算法 作者：July二零一一年一月一日 --------------------------------- 本人参考：算法导论 本人声明：个人原创，转载请注明出处。 ok，开始。 翻遍网上，关于此类BFS和DFS算法的文章，很多。但，都说不出个所以然来。读完此文，我想，你对图的广度优先搜索和深度优先搜索定会有个通通...
DFS 洛谷经典题P1036 P1135 P1037 P1118 P1123 P1025 P1077 P1434 P1406
春弦的博客
01-11 788
P1036 [NOIP2002 普及组] 选数 #include<bits/stdc++.h> using namespace std; int a[21]; int n,k,ans; bool is_prime(int x) { for(int i=2;i*i<=x;i++) { if(x%i==0) return 0; } return 1; } void dfs(int cnt,int sum,int start) { if(cnt==k)//已经选出k个数
DFS-BFS搜索专题【经典训练题】【有时间一个个做下来】
风尘_浪子
07-06 3930
有时间要去做做这些题目，所以从他人空间copy过来了，谢谢那位大虾啦。 pku 1175 Starry Night 题目地址：http://acm.pku.edu.cn/JudgeOnline/problem?id=1175 解法：BFS，要注意的是如何判断图形是一样的，我的做法就是计算每两个点的距离之和。 看：http://hi.baidu.com/doxi_free/blog/it
P5318 【深基18.例3】查找文献 【DFS + BFS】
ln2037的博客
10-08 295
题目描述 小K 喜欢翻看洛谷博客获取知识。每篇文章可能会有若干个（也有可能没有）参考文献的链接指向别的博客文章。小K 求知欲旺盛，如果他看了某篇文章，那么他一定会去看这篇文章的参考文献（如果他之前已经看过这篇参考文献的话就不用再看它了）。 假设洛谷博客里面一共有 n(n≤105)n(n\le10^5)n(n≤105) 篇文章（编号为 1 到 nnn）以及 m(m≤106)m(m\le10^6)m(m≤106) 条参考文献引用关系。目前小 K 已经打开了编号为 1 的一篇文章，请帮助小 K 设计一种方法，使小
洛谷P1443 DFS/BFS双做法（全部AC）
MATT1130的博客
10-09 508
洛谷P1443DFS/BFS双做法DFSBFS DFS dfs的做法网上很多dalao们都说玩写不起，但是多亏了一位dashen的帮助，最后写通了dfs。先上代码（各位想抄代码的朋友们看到这个就OK了）： #include <bits/stdc++.h> using namespace std; const int maxn = (4e2 + 8); int a[maxn][maxn], n, m, sx, sy; int nt[8][2] = {{1, 2}, {2, 1}, {2, -1},
洛谷 P1443 马的遍历(dfs,bfs,设阈值,减枝
yxrzibinanhai的博客
08-02 610
洛谷 P1443 马的遍历(dfs,bfs,设阈值,减枝 洛谷 P1443 马的遍历 我们都知道dfs是一条路搜到黑，所以不可以保证最开始搜到的就是最近点。也就是说，我们在遍历的过程中，结果是在不断更新的。 那么就是说我们把马所有可能走的路径全都搜索了一遍，有很多搜索都是累赘的。 dfs的优化：如果一个点已经搜过，且之前的值比新值小，则结束。 然后不出意料地TLE了~~ 再次优化，设置阈值，步数如果超过200就结束。 DFS全代码奉上： #include <iostream> #include
洛谷P3958 奶酪(bfs)
Eternally831143的博客
09-18 388
P3958 奶酪 题解 先对球按照高度(即zzz坐标)排个序，对于每个球，我们对与它相交或者相切的球建边，然后从最下面的球开始bfsbfsbfs就好了。(坑点：有可能与下表面相交或相切的不止一个，还有距离要用double…) 代码 #include&lt;bits/stdc++.h&gt; using namespace std; struct ball{ int x,y,z; bool...
搜索专题（BFS、DFS）持续更新 —— 洛谷题目
m0_50176535的博客
01-18 2886
搜索篇 ——洛谷 一、马的遍历 题目链接：P1443 马的遍历 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn) 题目描述 有一个 n * m 的棋盘，在某个点 (x, y) 上有一个马，要求你计算出马到达棋盘上任意一个点最少要走几步。（中国象棋里面的马，不知道怎么走的小伙伴可以百度）。 输入格式 输入只有一行四个整数，分别为 n, m, x, y。 输出格式 一个 n * m 的矩阵，代表马到达某个点最少要走几步（左对齐，宽 5 格，不能到达则输出 −1）。 输入输出样例 输入 #1 3
洛谷 - 马的遍历 (bfs搜索)
give it a try
06-03 376
题目传送 题意: 思路: 这里要注意，由于马是走‘日’字的，也就是马在象棋上的走路方式。 那么这里的方向数组就不止是普普通通的上下左右了，而是8种情况。所以这里的方向数组要变化一下，其他的就是bfs遍历基操了，bfs遍历先到的点，一定是最短的。 #include <bits/stdc++.h> inline int read(){char c = getchar();int x = 0,s = 1; while(c < '0' || c > '9') {if(c == '-') s
BFS模板【洛谷P1162】
KIKO_caoyue的博客
10-18 305
奉上题目链接啦：https://www.luogu.org/problemnew/show/P1162 一开始是懵的，这咋搜啊，在圈里咋限定方向啊，这咋做啊！！？？？？ 在队友@TDD的启发下，原来我们反其道而行之，题目要求在圈里填数字，我们从四条边向图里面搜，把圈外的都填上-1，最后把0当成2输出，就OK啦！！！   咦？怎么输出出来还是和原来的一样，怎么没有2啊？？？？？ 哦哦哦，起...
BFS（广度优先搜索）----洛谷--填涂颜色
Leo_zehualuo的博客
01-10 453
题目 题目链接 题目描述 由数字0组成的方阵中，有一任意形状闭合圈，闭合圈由数字1构成，围圈时只走上下左右4个方向。现要求把闭合圈内的所有空间都填写成2.例如：6×6的方阵（n=6），涂色前和涂色后的方阵如下： 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 0 0 1 1 1 0 0 0 1 1 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 ...
离开中山路（BFS）
Koutoto的博客
04-14 227
题目背景 《爱与愁的故事第三弹·shopping》最终章。 题目描述 爱与愁大神买完东西后，打算坐车离开中山路。现在爱与愁大神在x1,y1处，车站在x2,y2处。现在给出一个n×n（n<=1000）的地图，0表示马路，1表示店铺（不能从店铺穿过），爱与愁大神只能垂直或水平着在马路上行进。爱与愁大神为了节省时间，他要求最短到达目的地距离（a[i][j]距离为1）。你能帮他解决吗？ 输入格式 第1行：一个数 n 第2行~第n+1行：整个地图描述（0表示马路，1表示店铺，注意两个数之间没有空格.
洛谷 P1605 迷宫【搜索】【DFS】【BFS】
Derrickhang的博客
03-26 976
洛谷 P1605 迷宫【搜索】【DFS】【BFS】
搜索题
七里的专栏
08-02 1674
一个很好的搜索题分类，共36道题。没有做完（估计做不完了），但收获很大。转载很多，已不知原作者是谁，但感谢原作者的分享。   pku1175 Starry Night 题目地址：http://acm.pku.edu.cn/JudgeOnline/problem?id=1175 解法：BFS，要注意的是如何判断图形是一样的，我的做法就是计算每两个点的距离之和。 看：http://hi.ba
BFS算法---洛谷1443马的遍历
naexting的博客
02-23 402
题目描述 有一个n*m的棋盘(1<n,m<=400)，在某个点上有一个马,要求你计算出马到达棋盘上任意一个点最少要走几步 输入格式 一行四个数据，棋盘的大小和马的坐标 输出格式 一个n*m的矩阵，代表马到达某个点最少要走几步**（左对齐，宽5格，不能到达则输出-1）** 输入输出样例 输入 3 3 1 1 输出 0 3 2 3 -1 1 2 1 4 题意是：先给出棋盘规格，然后给出马的坐标，棋盘坐标是从（1,1）开始的，（从给出的样例可以看出），所以我们在存棋盘
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值