[AcWing算法刷题]之DFS+BFS迷宫模板（简单）

已于 2022-03-26 16:44:04 修改
阅读量4.9k 收藏 4
点赞数 3
分类专栏： AcWing算法刷题 文章标签： 算法 蓝桥杯 图论 c++ 深度优先
于 2022-03-26 16:38:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lihua777/article/details/123756733
版权

题目来源：

题库 - AcWing

目录

DFS和BFS模板题目：迷宫类

        机器人的运动范围​

        字母

        迷宫

        红与黑

        棋盘问题

        马走日

        全球变暖

DFS综合类

        乘积最大（提高课）

        单词接龙（提高课）

        取石子游戏（dfs数学推理）

机器人的运动范围

 BFS：

class Solution {
public:

    int get_sum(pair<int, int> p) {
        int s = 0;
        while (p.first) {
            s += p.first % 10;
            p.first /= 10;
        }
        while (p.second) {
            s += p.second % 10;
            p.second /= 10;
        }
        return s;
    }

    int movingCount(int threshold, int rows, int cols)
    {
        if (!rows || !cols) return 0;
        queue<pair<int,int>> q;
        vector<vector<bool>> st(rows, vector<bool>(cols, false));

        int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

        int res = 0;
        q.push({0, 0});
        while (q.size()) {
            auto t = q.front();
            q.pop();
            if (st[t.first][t.second] || get_sum(t) > threshold) continue;
            res ++ ;
            st[t.first][t.second] = true;
            for (int i = 0; i < 4; i ++ ) {
                int x = t.first + dx[i], y = t.second + dy[i];
                if (x >= 0 && x < rows && y >= 0 && y < cols) q.push({x, y});
            }
        }

        return res;
    }
};

DFS：

class Solution {
public:
int k;
int b,a;
int f[52][52];
int dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
    int movingCount(int threshold, int rows, int cols)
    {
        memset(f,false,sizeof f);
        b=cols,a=rows;

         int res=0;

        k=threshold;

        return    dfs(0,0);
    }
    int dfs(int y,int x)
    {
        if(x<0||x>=a||y<0||y>=b||f[y][x]) return 0;

         f[y][x]=true;
        int res=0;
        int x1=x,y1=y;
        while(x1)
        {
            res+=(x1%10);
            x1/=10;
        }
         while(y1)
        {
            res+=(y1%10);
            y1/=10;
        }

        if(res>k) return 0;
        int sum=0;

        for(int i=0;i<4;i++)
        {
            int q=x+dx[i],p=y+dy[i];
            sum+=dfs(p,q);
        }


         return sum+1;
    }
};

作者：dfbdberberb
链接：https://www.acwing.com/solution/content/11722/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

乘积最大（较难）

 

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

int n, k, ans;
string str;
bool st[20];//标记数字是否出现过
vector<int>num;//存放分割的数字

int number(int l, int r)//求区间[l,r]的数字
{
    int res = 0;
    for (int i = l; i <= r; i++)
        res = res * 10 + str[i] - '0';
    return res;
}

void dfs(int pos, int cnt)//枚举到的第几个空位，乘号的当前个数
{
    if (cnt == k)//如果乘号个数==题目所给的乘号个数
    {
        int y = number(pos, n - 1);//求出分割k次以后，第k+1个数的大小
        num.push_back(y);//放入分割的数字中
        int tmp = 1;
        for (int i = 0; i < num.size(); i++)//求乘积
            tmp *= num[i];
        //          cout<<num[i]<<" ";
        //      cout<<endl;
        ans = max(ans, tmp);//更新最大值
        num.pop_back();
        return;
    }
    for (int i = 0; i < n - 1; i++)//枚举分割位置
    {
        if (!st[i] && pos <= i)//如果分割位置未出现过，向下搜索
        {
            int x = number(pos, i);
            num.push_back(x);
            st[i] = true;
            dfs(i + 1, cnt + 1);
            st[i] = false;
            num.pop_back();
        }
    }
}

int main()
{
    cin >> n >> k;
    cin >> str;
    dfs(0, 0);
    cout << ans << endl;
    return 0;
}

字母

 

 BFS：

需要额外开一个字母数组来哈希快速找到该字母是否之前已经走过

#include<iostream>
#include<string>
#include<vector>
#include<queue>
#include<algorithm>
#include<memory.h>
#include<cstring>
using namespace std;

int n, m;
const int N = 50;
vector<string> V;
int mp[26];

struct STATE {
	int x, y;
	int mp[26];
	int step;
};

int ans = -1;
int addx[4] = { 1,-1,0,0 };
int addy[4] = { 0,0,-1,1 };

void bfs()
{
	queue<struct STATE> q;
	struct STATE s;
	memset(s.mp, 0, sizeof s.mp);
	s.mp[V[0][0] - 'A'] = 1;//标记
	s.step = 1;
	s.x = 0, s.y = 0;

	q.push(s);
	while (q.size())
	{
		auto t = q.front();
		q.pop();
		ans = max(ans, t.step);
		
		for (int i = 0; i < 4; i++)
		{
			int newx = t.x + addx[i];
			int newy = t.y + addy[i];
			
			if (newx >= 0 && newx < n && newy >= 0 && newy < m)
			{
				int idx = V[newx][newy] - 'A';
				if (t.mp[idx] == 1) continue;
				struct STATE next;
				next.x = newx;
				next.y = newy;
				next.step = t.step + 1;
				memcpy(next.mp, t.mp, sizeof t.mp);
				next.mp[idx] = 1;

				q.push(next);
			}
		}
	}
}

int main()
{
	cin >> n >> m;

	for (int i = 0; i < n; i++)
	{
		string s;
		cin >> s;
		V.push_back(s);
	}

	bfs();
	cout << ans << endl;

	return 0;
}

DFS：

同样需要开一个字母数组，来判断该字母是否出现过

不同的地方在与DFS搜索迷宫具有对称性：标记（   ）搜索下一层（  ）取消标记

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;

int n, m;
const int N = 50;
vector<string> V;
int mp[26];
int ans = -1;

int addx[] = { 1,-1,0,0 };
int addy[] = { 0,0,-1,1 };

void dfs(int x, int y, int step)
{
	int idx = V[0][0] - 'A';
	mp[idx] = 1;

	for (int i = 0; i < 4; i++)
	{
		int newx = x + addx[i];
		int newy = y + addy[i];

		if (newx >= 0 && newx < n && newy >= 0 && newy < m)
		{
			int idx = V[newx][newy] - 'A';
			if (mp[idx] == 1) continue;
			mp[idx] = 1;
			dfs(newx, newy, step + 1);
			mp[idx] = 0;
		}
	}
	ans=max(ans,step);
}

int main()
{
	cin >> n >> m;

	for (int i = 0; i < n; i++)
	{
		string s;
		cin >> s;
		V.push_back(s);
	}

	dfs(0, 0, 1);
	cout << ans << endl;

	return 0;
}

迷宫

 

 BFS：

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;

typedef pair<int, int> PII;
const int N = 110;
int n;
char g[N][N];
bool st[N][N];
queue<PII> q;
int startx, starty;
int endx, endy;

int dx[4] = { -1,0,1,0 };
int dy[4] = { 0,1,0,-1 };

void bfs()
{
	q.push({ startx,starty });
	st[startx][starty]=true;
	while (q.size())
	{
		auto t = q.front();
		q.pop();
		
		for (int i = 0; i < 4; i++)
		{
			int x = t.first + dx[i];
			int y = t.second + dy[i];
			if (x >= 0 && x < n && y>=0 && y < n && !st[x][y] && g[x][y] == '.')
			{
				st[x][y] = true;
				q.push({ x,y });
			}
			else continue;
		}
	}
}

int main()
{
	int T;
	cin >> T;
	while (T--)
	{
		cin >> n;
		for (int i = 0; i < n; i++) cin >> g[i];

		cin >> startx >> starty;
		cin >> endx >> endy;

		bfs();
		
        if(g[startx][starty]=='#' || g[endx][endy]=='#' || !st[endx][endy])cout << "NO" << endl;
		else if (st[endx][endy]) cout << "YES" << endl;
		

		memset(st, false, sizeof st);
	}

	return 0;
}

DFS：

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110;

char g[N][N];
bool st[N][N];
int n;
int l1, r1, l2, r2;
int dx[] = {0, -1, 0, 1}, dy[] = {-1, 0, 1, 0};
bool dfs(int x, int y)
{
    if(x == l2 && y == r2)return true;
    st[x][y] = true;
    for(int i = 0; i < 4; i ++)
    {
        int a = x + dx[i], b = y + dy[i];
        if(a < 0 || a >= n || b < 0 || b >= n)continue;
        if(g[a][b] == '#')continue;
        if(st[a][b])continue;
        if(dfs(a, b))return true;
    }
    return false;
}

int main()
{
    int T;
    cin >> T;
    while(T --)
    {
        memset(st, false, sizeof st);
        cin >> n;
        for(int i = 0; i < n; i ++) cin >> g[i];
        cin >> l1 >> r1 >> l2 >> r2;
        if(g[l1][r1] == '#' || g[l2][r2] == '#')
        {
            puts("NO");
            continue;
        }
        if(dfs(l1, r1))puts("YES");
        else puts("NO");
    }
    return 0;
}

红与黑

 

 DFS：

#include<iostream>
#include<cstring>
using namespace std;
const int N=25;
char g[N][N];
bool st[N][N];
int n,m;
int dx[4]={-1,0,1,0};
int dy[4]={0,1,0,-1};

int dfs(int x,int y)
{
    int cnt=1;
    st[x][y]=true;
    
    for(int i=0;i<4;i++)
    {
        int a=x+dx[i];
        int b=y+dy[i];
        if(a<0 || a>=n || b<0 || b>=m) continue;
        if(g[a][b]!='.') continue;
        if(st[a][b]) continue;
        
        cnt+=dfs(a,b);
    }
    return cnt;
}

int main()
{
	while (cin >> m >> n, n || m)
	{
		for (int i = 0; i < n; i++) cin >> g[i];

		int x, y;
		for(int i=0;i<n;i++)
			for (int j = 0; j < m; j++)
			{
				if (g[i][j] == '@')
				{
					x = i;
					y = j;
				}
			}
		memset(st, 0, sizeof st);
		cout << dfs(x, y) << endl;
	}

	return 0;
}

棋盘问题

 

//DFS
//类似于八皇后的一道多了一些限制的题

#include <cstdio>
#include <iostream>
#include <cstring>

using namespace std;

const int N = 20;

char g[N][N];                                       //存储输入棋盘 
int ans;                                            //存储答案 
int n, k;
int m;                                              //存储已近放入棋盘的棋子数 
bool line[N];                                       //存储当前列上有没有其他棋子 

void dfs(int x)
{
    if(m == k)                                      //当棋子放光的时候 
    {
        ans++;
        return;
    }

    if(x == n)                                      //防止越界 
        return;
    
    dfs(x + 1);     //这个是关键，因为 k <= m，因此可能有行不用放棋子，所以我们要手动舍弃行，直接进入下一行 
    for(int i = 0; i < n; i++)                      //爆搜 
        if(!line[i] && g[x][i] == '#')
        {
            line[i] = true;
            m++;                                    //记录放入的棋子数 
            dfs(x + 1);
            line[i] = false;                        //还原初始状态 
            m--;
        }

    
}

int main()
{
    while(scanf("%d%d", &n, &k) && n != -1 && k != -1)
    {
        ans = m = 0;
        for(int i = 0; i < n; i++)
            for(int j = 0; j < n; j++)
                cin >> g[i][j];

        dfs(0);
        cout << ans << endl;
    }

    return 0;
}

取石子游戏

 

#include<iostream>
#include<algorithm>
using namespace std;

int n, m;

void dfs(int a, int b, int step)
{
	if (a % b == 0 || a / b >= 2)
	{
		if (step & 1)
		{
			cout << "win" << endl;
			return;
		}
		else
		{
			cout << "lose" << endl;
			return;
		}
	}
	dfs(b, a % b, step + 1);
}

int main()
{
	while (cin >> n >> m, n || m)
	{
		if (n < m) swap(n, m);
		if (n / m >= 2) cout << "win" << endl;
		else dfs(n, m, 1);
	}

	return 0;
}

马走日

#include<bits/stdc++.h>
using namespace std;
int T,n,m,a,b,ans;
int vis[20][20];
int dx[8]={2,1,-1,-2,-2,-1,1,2};//方向数组
int dy[8]={1,2,2,1,-1,-2,-2,-1};//方向数组
void dfs(int x,int y,int step)//step记录当前走了几个格子
{
    if(step==n*m){//已遍历完所有的格子
        ans++;//答案加一
        return;
    }
    for(int i=0;i<8;i++){
        int kx=x+dx[i];
        int ky=y+dy[i];
        if(kx>=0&&kx<n&&ky>=0&&ky<m&&vis[kx][ky]==0){//判断
            vis[kx][ky]=1;//标记
            dfs(kx,ky,step+1);
            vis[kx][ky]=0;//回溯
        }
    }
}
int main()
{
    scanf("%d",&T);
    while(T--){//多组测试数据
        ans=0;//一定要记得清空数据
        memset(vis,0,sizeof(vis));
        scanf("%d %d %d %d",&n,&m,&a,&b);
        vis[a][b]=1;//标记起点
        dfs(a,b,1);
        printf("%d\n",ans);
    }
    return 0;
}

单词接龙（提高课）

 

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 21;

int n;
string word[N];
int g[N][N];//代表编号i的可以被j拼接  如i：asd，j：sdf，拼接长度为最小值g[i][j] = 2，i从0开始记位
int used[N];//编号为i的单词使用次数
int ans;

void dfs(string dragon, int last)
{
    ans = max((int)dragon.size(), ans);//取最大值，dragon.size()为当前合并的长度

    used[last]++;//编号为last的单词被用次数++；

    for (int i = 0; i < n; i++)
        if (g[last][i] && used[i] < 2)//used[i]<2代表单词用次数不超过2
            dfs(dragon + word[i].substr(g[last][i]), i); //编号为last的可以被i拼接现在尾巴为i号

    used[last]--;//恢复现场
}

int main() {
    cin >> n;
    for (int i = 0; i < n; i++) cin >> word[i];
    char start;
    cin >> start;//首字母

    for (int i = 0; i < n; i++)//遍历得到各个g[i][j]
        for (int j = 0; j < n; j++) {
            string a = word[i], b = word[j];
            for (int k = 1; k < min(a.size(), b.size()); k++)
                if (a.substr(a.size() - k, k) == b.substr(0, k)) {
                    g[i][j] = k;
                    break;
                }
        }

    for (int i = 0; i < n; i++)//找到首字母为strat的单词开始做dfs，dfs中会自动找到最大值
        if (word[i][0] == start)
            dfs(word[i], i);//从word[i]开始遍历，i代表现在是第几个单词

    cout << ans << endl;

    return 0;
}

全球变暖

 

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define x first
#define y second
using namespace std;
typedef pair<int, int> PII;
const int N = 1010;
int n;
char g[N][N];
bool st[N][N];
PII q[N * N];
int dx[4] = { -1,0,1,0 };
int dy[4] = { 0,1,0,-1 };
// total : 岛屿的板块的数量  bound：邻接海洋的岛屿板块的数量
void bfs(int sx, int sy, int& total, int& bound)
{
	int hh = 0;
	int tt = 0;
	q[0] = { sx,sy };
	st[sx][sy] = true;

	while (hh <= tt)
	{
		PII t = q[hh++];

		total++;
		bool is_bound = false;
		for (int i = 0; i < 4; i++)
		{
			int x = t.x + dx[i];
			int y = t.y + dy[i];
			if (x < 0 || x >= n || y < 0 || y >= n) continue;
			if (st[x][y]) continue;//如果已经走过了
			if (g[x][y] == '.')//上下左右之中有一个为海
			{
				is_bound = true;
				continue;
			}
			q[++tt] = { x,y };
			st[x][y] = true;
		}
		if (is_bound) bound++;//只要上下左右之中有一个为海，那么它就是边界
	}
}

int main()
{
	cin >> n;

	for (int i = 0; i < n; i++) cin >> g[i];

	int cnt = 0;
	for(int i=0;i<n;i++)
		for(int j=0;j<n;j++)
			if (!st[i][j] && g[i][j] == '#')
			{
				int total = 0;
				int bound = 0;
				bfs(i, j, total, bound);
				if (total == bound) cnt++;
			}
	cout << cnt << endl;

	return 0;
}

lihua777
关注
专栏目录
C++-VS2019-迷宫寻路BFS+DFS代码.zip
07-22
最终效果是实现了Prim随机生成迷宫，BFS&DFS路径显示、最短路长度显示、过程动态展示，主函数中有菜单，操作方便。 不仅可以用来读代码长知识、还可以用作算法演示。 附带第五版的exe文件，欢迎使用！
acwing基础课——DFS
qq_62417282的博客
11-30 486
acwing基础课二刷
【LeetCode & 剑指offer刷题】回溯法与暴力枚举法题3：13 机器人的运动范围
技术改变世界
01-06 590
【LeetCode &amp; 剑指offer刷题】回溯法与暴力枚举法题3：13 机器人的运动范围 【LeetCode &amp; 剑指offer 刷题笔记】目录（持续更新中...） 13 机器人的运动范围 题目描述 地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标...
剑指offer 面试题：机器人的运动范围
别说话写代码的博客
03-04 173
题目：地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？ 思路：用一个二维数组表示每个位置是否被 访问，...
DFS【Acwing】
Melody_Gogo的博客
07-04 207
【DFS】1. 排列数字 2. n-皇后
dfs和bfs算法详解.md
最新发布
04-13
DFS（深度优先搜索）和BFS（广度优先搜索）是两种在计算机科学中非常重要的图遍历算法，它们在处理树或图结构时具有不同的特点和应用场景。 深度优先搜索（DFS）是一种回溯算法，它沿着一条路径深入直至无法继续，...
算法之BFS与DFS
10-19
**算法之BFS（广度优先搜索）与DFS（深度优先搜索）** 在计算机科学中，图论和算法是至关重要的部分，而BFS（广度优先搜索）和DFS（深度优先搜索）是两种最基础且广泛使用的图遍历算法。它们在解决各种问题时起到...
bfs-dfs.rar_BFS algoritm_BFS+c++
09-22
BFS和DFS是图论和算法领域中非常基础且重要的搜索策略，广泛应用于解决各种问题，例如在社交网络中查找最近公共祖先、在迷宫中寻找出路等。通过理解这两种算法，可以提高解决问题的能力并为学习更复杂的算法打下基础...
ACM算法设计-BFS-DFS详解_算法_dfs_ACM_zoouts_bfs_
10-01
在计算机科学领域，特别是算法设计中，BFS（广度优先遍历）和DFS（深度优先遍历）是两种常用图或树结构的遍历方法。这两种算法在解决许多问题时发挥着至关重要的作用，例如在寻找最短路径、解决迷宫问题、网络爬虫...
acwing DFS BFS学习笔记
qq_55670428的博客
12-23 229
DFS注意顺序一条路走到黑即选择一个方法一直走到尾部，到尾部之后返回上一个节点判断另一个方案直到本节点可以访问的节点区别访问完毕桉树型结构来理解的话类似前序遍历树的前序遍历是指对于树中的每个节点，先访问该节点，然后递归地访问该节点的左子树，再递归地访问该节点的右子树。树的中序遍历是指对于树中的每个节点，先递归地访问该节点的左子树，再访问该节点，最后递归地访问该节点的右子树。树的后序遍历是指对于树中的每个节点，先递归地访问该节点的左子树，再递归地访问该节点的右子树，最后访问该节点。
acwing算法基础 dfs与bfs
a7546391的博客
10-25 256
不撞南墙不回头，空间复杂度是n，不具有最短路效应，适合一些思路比较奇怪，对空间要求高的题目。从根节点开始向下一层一层的搜索，具有最短路的特点，适用于需要找最短路的题目。
迷宫问题 (dfs深度优先搜索)【模板】
G_matinal的博客
01-12 539
dfs作为暴力搜索的一种，固然有着相对应的模板，在此我把我的模板分享给大家，这里我以一道例题的形式把让大家理解迷宫问题的dfs写法以及会用dfs写法。
Acwing dfs+回溯专题题解
qq_48344603的博客
07-14 333
17-电话号码的字母组合 其实就是map那个感觉有点麻烦，其他还行 46-全排列 next_permutation函数，产生所有的下一个组合，所以要先升序排序，保证能有所有下一组合 全排列II next_permutation就是返回不重复的，所以可以继续使用 ...
迷宫问题-bfs
qq_45772483的博客
02-20 610
给定一个 n×nn×n 的二维数组，如下所示： 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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。 数据保证至少存在一条从左上角走...
二分 AcWing 790. 数的三次方根
T_Y_F_的博客
06-19 344
二分 AcWing 790. 数的三次方根
迷宫ACWing(dfs不需要回溯)
weixin_46503238的博客
05-05 183
dfs不需要回溯，因为你搜过了证明这个方向是否可行结果就的出来了，那么你回溯的话会造成一直死在里面不出来，一直打圈在里面。
【AcWing】1112. 迷宫（DFS连通性）
weixin_40994937的博客
04-06 326
题目描述 给定起点和终点，问是否有这样一条路能够连通。 输入格式 输出格式 数据范围 1≤n≤1001≤n≤1001≤n≤100 输入样例 2 3 .## ..# #.. 0 0 2 2 5 ..... ###.# ..#.. ###.. ...#. 0 0 4 0 输出样例 YES NO 算法 这题就是典型的连通性问题，属于模板题，注意起点和终点可能不合法 #include <bits...
暑假acwing算法总结12：dfs与bfs
cjp_kangkang_的博客
07-15 122
1、dfs深度优先搜索 dfs很讲究很执着，一条路不走到头不会回来，往树深处搜 基于栈 空间复杂度：o(h)树高 第一次搜到的点：不具有最短性 2、bfs广度优先搜索 bfs不讲究很渣男，眼观六路耳听八方，一层一层搜 基于队列 空间复杂度：o(2h) 第一次搜到的点：具有最短性 ...
奇偶性剪枝优化DFS+BFS搜索算法
深度优先搜索（DFS）和广度优先搜索（BFS）是两种常用的搜索算法，它们在处理这类问题时有着不同的策略。DFS更像树的先根遍历，它会尽可能深地探索一条路径，直到无法继续为止，然后回溯到其他未探索的分支。这在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值