DFS/BFS----迷宫专题（暑期训练2）

最新推荐文章于 2024-05-21 23:16:53 发布
最新推荐文章于 2024-05-21 23:16:53 发布
阅读量152 收藏 1
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dabaitutunaitang/article/details/120016871
版权

目录

DFS求油田连通块数----Oil Deposits

双向BFS----NightmareⅡ（HDU3085）

两遍BFS----Fire！（UVA-11624）

Find a way(HDU2612)

救公主--A计划（HDU2102）

DFS----棋盘问题

DFS求油田连通块数----Oil Deposits

双向BFS----NightmareⅡ（HDU3085）

题意：

男孩和女孩两人被困在一个大迷宫里，迷宫里有两个鬼魂。男孩想知道他是否能在鬼魂找到女孩之前找到她。两人可以在四个方向移动，每一秒，男孩能走三步，女孩能走一步。鬼魂每隔一秒它们就会分裂成几个部分，无视墙壁，在四个方向上都占领2个网格，直到它们占领整个迷宫。

你可以假设，每一秒，鬼魂先扩散，然后男孩女孩开始移动，如果人和鬼魂到达一个格子，他们就会死亡。注:新鬼也可以和原鬼一样继续分裂。

 思路：

双向BFS,男孩每轮拓展3次,女孩每轮拓展1次,一个记录女孩走过哪些地方，另一个记录男孩。假设在t时刻，两人相遇，那么如果此时他们中任何一人与魔鬼的曼哈顿距离小于2*t，即魔鬼能够走的路程，那么他们将在相遇前被魔鬼吃掉，反之则可以相遇。

 AC代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<string>
#include<string.h>
#include<cstdlib>
#include<fstream>
#include<queue>
#include<stack>
#include<map>
#include<set>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
const ll maxn=810;
int n,m,mx,my,gx,gy,z1x,z1y,z2x,z2y,step;
int dir[4][2]= {{0,1},{1,0},{0,-1},{-1,0}};
char mp[maxn][maxn];
bool vis[2][maxn][maxn];
struct Node
{
    int x,y;
};
queue<Node> Q[2];
 
bool judge(int x,int y)
{
    //step*2则是因为鬼魂每次移动两个单元格
    //曼哈顿距离其实就是当前位置到鬼魂位置的最短距离，但是是基于单元格的最短距离而非直线距离
    if((abs(x-z1x)+abs(y-z1y))<=2*step||(abs(x-z2x)+abs(y-z2y))<=2*step)//判断当前位置到达鬼魂处的曼哈顿距离
        return 0;
    return 1;
}
 
int bfs(int t)
{
    int cnt=Q[t].size();//只需要搜索某一时刻的点
    while(cnt--)
    {
        Node now=Q[t].front();
        Q[t].pop();
        if(!judge(now.x,now.y))//鬼魂先移动，所以先判定是否有遇到鬼魂的可能
            continue;
        for(int i=0; i<4; i++)
        {
            int xx=now.x+dir[i][0];
            int yy=now.y+dir[i][1];
            if(xx<0||xx>=n||yy<0||yy>=m)//判断是否越界
                continue;
            if(vis[t][xx][yy]||mp[xx][yy]=='X')
                continue;
            if(!judge(xx,yy))
                continue;
            if(vis[t^1][xx][yy])//判断另一个人是否到达过这个位置，到达了说明两人相遇，输出结果
                return 1;
            vis[t][xx][yy]=true;
            Q[t].push((Node){xx,yy});
        }
    }
    return 0;
}
 
int slove()
{
    step=0;
    memset(vis,false,sizeof(vis));
    while(!Q[0].empty())//循环之中需要初始化数据防止后续数据受到影响
        Q[0].pop();
    while(!Q[1].empty())
        Q[1].pop();
    vis[0][mx][my]=vis[1][gx][gy]=true;
    Q[0].push((Node){mx,my});
    Q[1].push((Node){gx,gy});
    while(!Q[0].empty()||!Q[1].empty())
    {
        step++;
        if(bfs(0)||bfs(0)||bfs(0)||bfs(1))//男孩一次走三个单元格，女孩一次一个单元格
            return step;
    }
    return -1;
}
 
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int zn=0;
        scanf("%d%d",&n,&m);
        memset(vis,false,sizeof(vis));
        for(int i=0; i<n; i++)
        {
            scanf("%s",mp[i]);
            for(int j=0; j<m; j++)
            {
                if(mp[i][j]=='M')//人物位置
                    mx=i,my=j;
                if(mp[i][j]=='Z')//鬼魂起点
                {
                    zn++;
                    if(zn==1)
                        z1x=i,z1y=j;
                    else
                        z2x=i,z2y=j;
                }
                if(mp[i][j]=='G')//人物位置
                    gx=i,gy=j;
            }
        }
        int ans=slove();
        printf("%d\n",ans);
    }
    return 0;
}

两遍BFS----Fire！（UVA-11624）

题意：

一个迷宫之中存在着一个人和一团火，要求人在被火烧死之前逃出这个迷宫，逃出迷宫的条件就是移动到迷宫的边界没有墙壁的地方，人和火都不能穿过墙壁，以及火呈蔓延式扩散，每一秒扩散四个方向（上下左右）。

思路：

火和人个跑一遍BFS

当这个人能跑出去时，我们需要满足两个条件：1、这个人不会被火堵住去路。2、这个人能找到出口，也就是没有墙壁的边界。因此我们需要对火和人都进行一次搜索，对于火的搜索就是这个火到达某一个地方需要多少时间；而对于人的搜索则是这个人是否在火到达之前到达了应该到达的位置或者这个人的下一步路有没有被火给堵上。

AC代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<cstring>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
const ll maxn=1005;
int n,m,sx,sy;
int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
char mp[maxn][maxn];
int times[maxn][maxn],step[maxn][maxn];
bool vis[maxn][maxn];
struct Node
{
    int x,y,step;
};
queue<Node> Q;
void Fire_bfs()
{
    while(!Q.empty())
    {
        Node now=Q.front();
        Q.pop();
        for(int i=0;i<4;i++)
        {
            int xx=now.x+dir[i][0];
            int yy=now.y+dir[i][1];
            if(xx>=1&&xx<=n&&yy>=1&&yy<=m&&!vis[xx][yy]&&mp[xx][yy]=='.')
            {
                vis[xx][yy]=true;
                times[xx][yy]=times[now.x][now.y]+1;
                Q.push((Node){xx,yy,times[xx][yy]});
            }
        }
    }
}
int J_bfs(int x,int y)
{
    step[x][y]=0;
    Q.push((Node){x,y,0});
    vis[x][y]=true;
    while(!Q.empty())
    {
        Node now=Q.front();
        Q.pop();
        if(now.x==1||now.x==n||now.y==1||now.y==m)//可以跑出去
            return step[now.x][now.y]+1;
        for(int i=0;i<4;i++)
        {
            int xx=now.x+dir[i][0];
            int yy=now.y+dir[i][1];
            if(xx>=1&&xx<=n&&yy>=1&&yy<=m&&!vis[xx][yy]&&mp[xx][yy]=='.')
            {
                if(step[now.x][now.y]+1<times[xx][yy])
                {
                    step[xx][yy]=step[now.x][now.y]+1;
                    vis[xx][yy]=true;
                    Q.push((Node){xx,yy,step[xx][yy]});
                }
            }
        }
    }
    return -1;
}

int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        cin>>n>>m;
        memset(vis,false,sizeof(vis));
        memset(times,INF,sizeof(times));//火到达该位置几秒后
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                cin>>mp[i][j];
                if(mp[i][j]=='J')
                    sx=i,sy=j;
                if(mp[i][j]=='F')
                {
                    vis[i][j]=true;
                    times[i][j]=0;
                    Q.push((Node){i,j,0});
                }
            }
        }
        Fire_bfs();
        while(!Q.empty())
           Q.pop();
        memset(vis,false,sizeof(vis));
        int ans=J_bfs(sx,sy);
        if(ans==-1)
            cout<<"IMPOSSIBLE"<<endl;
        else
            cout<<ans<<endl;
    }
    return 0;
}

Find a way(HDU2612)

题意：

"Y"点与"M"要见面到KFC吃饭，"@“点代表KFC(地图中不止存在一家KFC)，”#“点代表墙，”."代表道路。

小Y和小M每走一格需要11min，输出两人会面所需的最短总时间(所用时间为两人用时相加)。

思路：

Y和M分别BFS，把到每个KFC的距离记录下来，然后遍历求用时和最小值。

AC代码：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
using namespace std;
int n,m;
char a[205][205];
int vism[205][205];
int visy[205][205];
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
struct node
{
    int x,y;
};
int bfsy(int x,int y)
{
	memset(visy,0,sizeof(visy));
	visy[x][y]=1;
	queue<node>q;
	node start={x,y};
	q.push(start);
	while(!q.empty())
    {
		node p=q.front();
		q.pop();
		for(int i=0; i<4; i++)
		{
			int nx=p.x+dx[i];
			int ny=p.y+dy[i];
			if(nx>=0&&nx<n&&ny>=0&&ny<m&&a[nx][ny]!='#'&&!visy[nx][ny])
			{
				visy[nx][ny]=visy[p.x][p.y]+1;
				node next={nx,ny};
				q.push(next);
			}
		}
	}
	return 0;
}
int bfsm(int x,int y)
{
	memset(vism,0,sizeof(vism));
	vism[x][y]=1;
	queue<node>q;
	node start={x,y};
	q.push(start);
	while(!q.empty())
    {
		node p=q.front();
		q.pop();
		for(int i=0; i<4; i++)
		{
			int nx=p.x+dx[i];
			int ny=p.y+dy[i];
			if(nx>=0&&nx<n&&ny>=0&&ny<m&&a[nx][ny]!='#'&&!vism[nx][ny])
			{
				vism[nx][ny]=vism[p.x][p.y]+1;
				node next={nx,ny};
				q.push(next);
			}
		}
	}
	return 0;
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        int ans=INT_MAX;
        int sx,sy;
        for(int i=0;i<n;i++)
           for(int j=0;j<m;j++)
            cin>>a[i][j];
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(a[i][j]=='Y')
                {
                    sx=i,sy=j;
                    break;
                }
            }
        }
        bfsy(sx,sy);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(a[i][j]=='M')
                {
                    sx=i,sy=j;
                    break;
                }
            }
        }
        bfsm(sx,sy);
         for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
               if(a[i][j]=='@'&&vism[i][j]&&visy[i][j])
                ans=min(ans,(vism[i][j]+visy[i][j]-2)*11);
            }
        }
        cout<<ans<<endl;
    }

}

救公主--A计划（HDU2102）

题意：

 思路：

多层的迷宫和一层迷宫差不多，只不过多了一个z轴上的移动。

但是我们要搞清楚这道题中上下层互换并不是我们主动形成的。
也就是说，你如果想去另一层，你不能自发地前往，你只能通过题目中提及到的“时空传输机”被动式的被传送到另一层。

注意：

遇到‘#’（时空传输机）两层之间的互换，利用的是异或的性质：
 

1^1==0
0^1==1

AC代码：

#include<bits/stdc++.h>
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int maxn=1e5+100;
struct node
{
    int x,y,h,step;
    node() {}
    node(int hh,int xx,int yy,int ss):x(xx),y(yy),h(hh),step(ss) {}
};
int n,m,t;
string mp[5][20];
bool vis[5][20][20];
int dx[4]= {1,-1,0,0};
int dy[4]= {0,0,1,-1};
 
int bfs()
{
    queue<node> q;
    memset(vis,false,sizeof(vis));
    q.push(node(0,0,0,0));
    vis[0][0][0]=true;
    while(!q.empty())
    {
        node tmp=q.front();
        q.pop();
        for(int i=0; i<4; i++)
        {
            int xx=tmp.x+dx[i];
            int yy=tmp.y+dy[i];
            int hh=tmp.h;
            if(xx>=0&&xx<n&&yy>=0&&yy<m&&!vis[hh][xx][yy]&&mp[hh][xx][yy]!='*')  //不超界，没走过，不是障碍物
            {
                vis[hh][xx][yy]=true;
                if(mp[hh][xx][yy]=='.')
                {
                    q.push(node(hh,xx,yy,tmp.step+1));
                }
                else if(mp[hh][xx][yy]=='#'){
                    if(mp[hh^1][xx][yy]=='.'&&!vis[hh^1][xx][yy]){
                        vis[hh^1][xx][yy]=true;
                        q.push(node(hh^1,xx,yy,tmp.step+1));
                    }
                    else if(mp[hh^1][xx][yy]=='P')
                        return tmp.step+1;
                }
                else if(mp[hh][xx][yy]=='P')
                    return tmp.step+1;
            }
        }
    }
    return -1;
}
int main()
{
//    cout<< (1^1) <<endl;
//    cout<< (0^1) <<endl;
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
    int c;
    cin>>c;
    while(c--)
    {
        cin>>n>>m>>t;
        for(int i=0; i<n; i++)
            cin>>mp[0][i];
        for(int i=0; i<n; i++)
            cin>>mp[1][i];
        int time=bfs();
        if(time==-1||time>t)
            cout<<"NO"<<endl;
        else
            cout<<"YES"<<endl;
    }
    return 0;
}

DFS----棋盘问题

题意：

 思路：

记录每一行/列是否有棋子，每次放置选择一列/行进行放置，并且规定当第k个棋子放在第i列时，第k+1个棋子需要放置在第i+1列~第n列。

AC代码：

#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
int n,m,ans;
char a[10][10];
bool vis[10];
void dfs(int x,int k)
{
    if(!k)
    {
        ++ans;
        return;
    }
    if(x==n)
        return;
    for(int i=0;i<n;i++)
    {
        if(!vis[i]&&a[x][i]=='#')
        {
            vis[i]=1;
            a[x][i]='.';
            dfs(x+1,k-1);
            vis[i]=0;
            a[x][i]='#';
        }
    }
    dfs(x+1,k);
}

int main()
{
	while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==-1&&m==-1)
            break;
        ans=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
              cin>>a[i][j];
            }
        }
        dfs(0,m);
        printf("%d\n",ans);
	}
    return 0;
}

笑醒*~*
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
dfs-bfs-master.zip_bfs_dfs
09-24
dfs-bfs-master 网上找到的 dfs和bfs演示
练习题 No.1 迷宫的最短路径(深度|宽度优先搜索)
一名小学生的辛酸奋斗史
03-11 1115
要求给定一个大小为n * m（n <= 100, m <= 100）的迷宫。迷宫由通道（0）和墙壁（#）组成，每一步可以向邻接的上下左右四格的通道移动。请求出从起点到终点所需的最小步数。请注意，本题假定从起点一定可以移动到终点。输入格式输入n、m、起点(x, y)、终点(x, y)输出格式输出从起点到终点的最短距离测试输入5 5 0 0 3 3 0 # 0 0 0 0 0 # 0 # 0 0 # 0
蓝桥杯DFS和BFS例题（学习笔记）
TGA麻辣香锅的博客
02-03 2131
前言： DFS和BFS都是图的遍历的两种形式。 DFS的特点是不具有BFS中按层次顺序遍历的特性，所以DFS不具有最优性。DFS因此常用来求解有没有的问题。DFS所得到的解不一定是最优解。当题目中出现问题是否有解等字眼时，常用DFS来求解。 BFS的特点是按照层次顺序遍历，因此，BFS可以用来求解最优解，当题目中出现最短路径，最少的时间等字眼时，常用BFS来求解。 BFS: 1.迷宫问题（输出最短字典序列） 下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可 以通行的地方。迷宫的
暑假集训-1 深搜（dfs）+广搜（bfs）
在人间负债^
12-17 600
暑假第一次训练就是深搜和广搜 ，虽然深搜和广搜在后面的使用不是很多，但刚开始对我这种小菜鸡来说还是有很大难度的，不少题目自己还是想不出来，看到别人的题解后就恍然大悟了，还是太菜了 A - 棋盘问题 POJ - 1321 在一个给定形状的棋盘（形状可能是不规则的）上面摆放棋子，棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列，请编程求解对于给定形状和大小的棋盘，摆放k个棋子的所有可行的摆放方案C。 Input 输入含有多组测试数据。 每组数据的第一行是两个正整数，n k，用一个空格隔.
暑假训练 迷宫寻宝(bfs)
wbl1970353515的博客
09-17 1431
题目描述 洪尼玛今天准备去寻宝，在一个n*n （n行, n列）的迷宫中，存在着一个入口、一些墙壁以及一个宝藏。由于迷宫是四连通的，即在迷宫中的一个位置，只能走到与它直接相邻的其他四个位置（上、下、左、右）。现洪尼玛在迷宫的入口处，问他最少需要走几步才能拿到宝藏？若永远无法拿到宝藏，则输出-1。 Input 多组测试数据。 每组数据输入第一行为正整数n，表示迷宫大小。 接下来n行，每行包括...
数据结构-DFS and BFS-PPT
02-04
数据结构-DFS and BFS-PPT
dfs_bfs.rar_C-C++_bfs
09-23
a program to find Dfs and bfs
leetcode池塘-DSA-BFS-DFS:DSA-BFS-DFS
06-30
网友DSA-BFS-DFS 广度优先搜索（BFS）和广度优先遍历 广度优先搜索 (BFS)是一种探索树或图的方法。 在 BFS 中，您首先探索一步之外的所有节点，然后探索两步之外的所有节点，依此类推。 广度优先搜索就像在池塘中央...
DFS-BFS-Implementations:UPenn 类的 DFS 和 BFS 实现
06-24
DFS_BFS UPenn 类的 DFS 和 BFS 实现在这个程序中，我创建了一个名为 AdjacencyStructure 的接口，其中包含添加、减去或更改边的各种方法。 我现在已经实现了一个 AdjacencyMatrix 类（我的主要数据结构），它是一个...
链接表存储图(C++注释详解): 构建表 & 深度优先遍历 (DFS)
H13420972436的博客
05-15 418
代码实现: 构建表 & 深度优先遍历 (DFS)
质数和约数
2302_77099705的博客
05-21 701
最大公约数（Greatest Common Divisor）指两个或多个整数共有约数中最大的一个。也称最大公因数、最大公因子，a， b的最大公约数记为（a，b），同样的，a，b，c的最大 公约数记为（a，b，c），多个 整数的最大公约数也有同样的记号。求最大公约数有多种 方法，常见的有 质因数分解法、 短除法、 辗转相除法、 更相减损法。
P1135 奇怪的电梯
loongnoy的博客
05-17 281
大楼的每一层楼都可以停电梯，而且第 𝑖i 层楼（1≤𝑖≤𝑁1≤i≤N）上有一个数字 𝐾𝑖Ki​（0≤𝐾𝑖≤𝑁0≤Ki​≤N）。例如： 3,3,1,2,53,3,1,2,5 代表了 𝐾𝑖Ki​（𝐾1=3K1​=3，𝐾2=3K2​=3，……），从 11 楼开始。第一行为三个用空格隔开的正整数，表示 𝑁,𝐴,𝐵N,A,B（1≤𝑁≤2001≤N≤200，1≤𝐴,𝐵≤𝑁1≤A,B≤N）。对于 100%100% 的数据，1≤𝑁≤2001≤N≤200，1≤𝐴,𝐵≤𝑁1≤A,B≤N，0≤𝐾𝑖≤𝑁0≤Ki​≤N。
【算法】前缀和——二维前缀和模板题
最新发布
2302_79031646的博客
05-21 182
用“二维前缀和模板题”来介绍二位前缀和算法模板
【二叉树算法题记录】从中序与后序遍历序列构造二叉树，从前序与中序遍历序列构造二叉树
weixin_43627638的博客
05-15 383
这样我们就能确定整棵树的根节点在。
算法练习第22天|39. 组合总和、40.组合总和II
Brillian123的博客
05-15 814
39. 组合总和39. 组合总和 - 力扣（LeetCode）
代码随想录算法训练营第五十五天|LeetCode583.两个字符串的删除操作 、LeetCode72.编辑距离
m0_64514622的博客
05-16 872
dp[i][j]:表示以下标i-1为结尾的word1,和以j-1为结尾的字符串word2，想要达到相等，所需要删除元素的最少次数。dp[i][j]:表示以下标i-1为结尾的word1,和以j-1为结尾的字符串word2，最近编辑距离为dp[i][j]word2为空字符串，以i-1为结尾的字符串word1要要删除i个元素才能和word2相同。word1为空字符串，以j-1为结尾的字符串word2要要删除j个元素才能和word1相同。操作三：word1替换word1[i-1]，使其与word2[j-1]相同。
LeetCode 108.将有序数组转换为二叉搜索树
2301_80211119的博客
05-18 815
给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 平衡 二叉搜索树。
爱吃香蕉的珂珂
青釉Oo的博客
05-15 239
爱吃香蕉的珂珂
迷宫bfs--一个起点，多个终点
07-10
好的，针对你的问题，我来简单解答一下。 对于一个起点和多个终点的迷宫问题，我们可以使用广度优先搜索算法（BFS）来解决。 具体的实现方法如下： 1. 将起点加入队列中，同时记录每个点的步数为0 2. 对于每个队列中的点，遍历其所有相邻的空格（即可以通行的空格），并将这些相邻点的步数设置为当前点的步数+1。 3. 如果相邻点是终点，则直接返回步数。 4. 如果相邻点不是终点，则将该相邻点加入队列中，继续遍历。 5. 如果队列为空，即无法到达终点，则返回-1。 需要注意的是，由于有多个终点，我们需要对每个终点都进行一次BFS，以获取到每个终点的步数。 希望这能对你有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值