BFS~~~迷宫

最新推荐文章于 2022-05-31 20:29:08 发布
最新推荐文章于 2022-05-31 20:29:08 发布
阅读量2k 收藏
点赞数
分类专栏： 解题 ACM 文章标签： struct 算法 input ini c class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuzengqiang/article/details/7498182
版权
解题 同时被 2 个专栏收录
26 篇文章 0 订阅
订阅专栏
ACM
24 篇文章 0 订阅
订阅专栏

例题1：NYOJ 58(最小步数)，保存每一步的步数即可，至于标程中是另外一种算法，后面的讨论个人觉得对这个代码的评价不好，因为标程中涉及到的是另外一种算法，不是说他不会用BFS进行广搜，他只是想告诉你这道题用Floyd-Warshall算法可用，不多说了，纯属个人言谈~~用BFS的时候记得把map放在main里面。

#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
int num,dx[4]={0,1,0,-1},dy[4]={-1,0,1,0};
class point{
public:
    int x,y,step;
    friend istream& operator>>(istream &input,point &P)
    {   input>>P.x>>P.y; 
        return input;
    }    
    bool operator==(point &P) const
    {   return x==P.x&&y==P.y;
    }             
}Start,End;
bool Inside(point p)
{   return p.x>=0&&p.x<9&&p.y>=0&&p.y<9; 
}
int BFS(int map[9][9])
{   queue<point> Q;
    point New,temp;
    Q.push(Start);
    map[Start.x][Start.y]=1;
    while(!Q.empty())
    {   temp=Q.front();
        Q.pop();
        if(temp==End) break;
        for(int i=0;i<4;i++)
        {   New.x=temp.x+dx[i];
            New.y=temp.y+dy[i];
            if(Inside(New)&&map[New.x][New.y]==0)
            {   map[New.x][New.y]=1;
                New.step=temp.step+1;
                Q.push(New);         
            }
        }
    }
    return temp.step;
}

int main()
{   cin>>num;
    while(num--)
    {   int map[9][9]={ 
            1,1,1,1,1,1,1,1,1,
            1,0,0,1,0,0,1,0,1,
            1,0,0,1,1,0,0,0,1,
            1,0,1,0,1,1,0,1,1,
            1,0,0,0,0,1,0,0,1,
            1,1,0,1,0,1,0,0,1,
            1,1,0,1,0,1,0,0,1,
            1,1,0,1,0,0,0,0,1,
            1,1,1,1,1,1,1,1,1
        };
        cin>>Start>>End;
        Start.step=0;
        cout<<BFS(map)<<endl;
    }
    return 0;
}

下面为标准程序：

#include<iostream> 
#include<cmath> 
using namespace std; 
int mz[9][9]={ 
    1,1,1,1,1,1,1,1,1, 
    1,0,0,1,0,0,1,0,1, 
    1,0,0,1,1,0,0,0,1, 
    1,0,1,0,1,1,0,1,1, 
    1,0,0,0,0,1,0,0,1, 
    1,1,0,1,0,1,0,0,1, 
    1,1,0,1,0,1,0,0,1, 
    1,1,0,1,0,0,0,0,1, 
    1,1,1,1,1,1,1,1,1 
}; 
inline int ABS(int a) 
{   return a>0?a:-a; 
} 
int len[10][10][10][10]; 
const int INF=100000; 
void FloydWarshall() 
{   for(int i=1;i!=8;i++) 
        for(int j=1;j!=8;j++) 
            for(int k=1;k!=8;k++) 
                for(int l=1;l!=8;l++) 
                    if(i==k && j== l) len[i][j][k][l]=0; 
                    else if(mz[i][j]==0 && mz[k][l]==0 && ABS(i-k)+ABS(j-l)==1) len[i][j][k][l]=1; 
                    else len[i][j][k][l]=INF; 
    int v=49; 
    for(int k=1;k!=8;k++) 
        for(int l=1;l!=8;l++)             
            for(int m=1;m!=8;m++) 
                for(int n=1;n!=8;n++) 
                    for(int i=1;i!=8;i++) 
                        for(int j=0;j!=8;j++) 
                            if(len[m][n][i][j]>len[m][n][k][l]+len[k][l][i][j]) len[m][n][i][j]=len[m][n][k][l]+len[k][l][i][j]; 
} 
int main() 
{   FloydWarshall(); 
    int n,a,b,c,d; 
    cin>>n;    
    while(n--)    
    {   cin>>a>>b>>c>>d;        
        cout<<len[a][b][c][d]<<endl;   
    }
    return 0;  
}

例题2：NYOJ 92，题目不难，就是要注意输入，先输入宽，再输入高。把图外边围一圈不是0的数再BFS搜就可以了，代码：

#include<iostream>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
const int MAX1=1450;
const int MAX2=970;
int num,wid,high;
int dx[4]={0,1,0,-1},dy[4]={-1,0,1,0};
#define CLR(arr,val) memset(arr,val,sizeof(arr))
int map[MAX2][MAX1];
struct point
{   int x,y;
}Start;
queue<point> Q;
bool Inside(point p)
{   return  p.x>=0&&p.x<=high+1&&p.y>=0&&p.y<=wid+1;
}
void BFS(int x,int y)
{   point New,start;
    start.x=x,start.y=y;
    Q.push(start);
    while(!Q.empty())
    {   start=Q.front();
        Q.pop();
        for(int i=0;i<4;i++) 
        {   New.x=start.x+dx[i];
            New.y=start.y+dy[i];
            if(Inside(New)&&map[New.x][New.y]!=0)
            {   map[New.x][New.y]=0;
                Q.push(New);
            }
        }
    }
}
int main()
{   scanf("%d",&num);
    while(num--)
    {   scanf("%d%d",&wid,&high);
        CLR(map,-1);
        for(int i=1;i<=high;i++)
            for(int j=1;j<=wid;j++)
                scanf("%d",&map[i][j]);
        BFS(0,0);
        for(int i=1;i<=high;i++)
        {   printf("%d",map[i][1]);
            for(int j=2;j<=wid;j++)
                printf(" %d",map[i][j]);
            printf("\n");        
        }
    }
    return 0;
}

例题3：NYOJ 284，就是要注意一点，当有砖块的时候，你只能用子弹打掉这块砖块将它做空地方处理，继续BFS，而不能我一打掉这块砖块就直接通过这个地方。

#include<iostream>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
const int MAX=350;
#define CLR(arr,val) memset(arr,val,sizeof(arr))
int n,m,dx[4]={0,1,0,-1},dy[4]={-1,0,1,0},visit[MAX][MAX];
char map[MAX][MAX];
struct point{
    point(){x=y=step=0;}
    point(int a,int b,int c):x(a),y(b),step(c){}
    bool operator==(point p) const {return x==p.x&&y==p.y;}   
    int x,y,step;
}Start,End;
queue<point> Q;
bool Inside(point p)
{   return p.x>=0&&p.x<n&&p.y>=0&&p.y<m; 
}
void BFS()
{   point temp,New;
	Q.push(Start);
	visit[Start.x][Start.y]=1;
    while(!Q.empty())
	{   temp=Q.front();
	    if(temp==End) break;
		Q.pop();
		if(map[temp.x][temp.y]=='B')
		{   temp.step++;
			Q.push(temp);
			map[temp.x][temp.y]='E';
            //只能先把这块砖先打掉,而不能打掉后直接通过这个地方,因为打掉这块砖后要把这个地方当做Empty来看,重新搜索 
		}
		else 
		for(int i=0;i<4;i++)
		{   New.x=temp.x+dx[i];
			New.y=temp.y+dy[i];
			char c=map[New.x][New.y];
			if(!visit[New.x][New.y]&&Inside(New)&&c!='S'&&c!='R')
			{   New.step=temp.step+1;
			    Q.push(New);
			    visit[New.x][New.y]=1;
			}
		}
    }
	if(Q.empty()) printf("-1\n");
	else  printf("%d\n",temp.step);
}
int main()
{   while(scanf("%d%d",&n,&m),n||m)
	{   getchar();
        CLR(visit,0);
		while(!Q.empty()) Q.pop();//不要把这个清空的放在最后面去了,WA了n次啊 
        for(int i=0;i<n;i++) gets(map[i]);
        for(int i=0;i<n;i++)
			for(int j=0;j<m;j++)
			{   if(map[i][j]=='Y') Start.x=i,Start.y=j;
				if(map[i][j]=='T') End.x=i,End.y=j;
			}
		BFS();
	}
	return 0;
}

例题4：NYOJ 27(水池数目)，这个是要求个数，解释不清楚，直接看代码吧：

#include<iostream>
#include<cstring>
#include<queue>
#include<cstdio>
using namespace std;
const int MAX=101;
#define CLR(arr,val) memset(arr,val,sizeof(arr))
int n,m,total,map[MAX][MAX];
int dx[4]={0,1,0,-1},dy[4]={-1,0,1,0};
struct Point 
{   int x,y; 
};
bool Inside(Point P)
{   return P.x>=0&&P.x<n&&P.y>=0&&P.y<m;
}
void BFS(int x,int y)
{   queue<Point> Q;
    Point s,New;
    s.x=x,s.y=y;
    Q.push(s);
    while(!Q.empty())
    {   s=Q.front();
        Q.pop();
        for(int i=0;i<4;i++)
        {   New.x=s.x+dx[i];
            New.y=s.y+dy[i];
            if(Inside(New)&&map[New.x][New.y]==1)
            {   map[New.x][New.y]=0;
                Q.push(New);
            }
        } 
    } 
    total++;
}
int main()
{   int Case,value;
    scanf("%d",&Case);
    while(Case--)
    {   scanf("%d%d",&n,&m);
        for(int i=0;i<n;i++) 
            for(int j=0;j<m;j++)
                {   scanf("%d",&value);
                    map[i][j]=value;
                }
        total=0;
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
                if(map[i][j]) BFS(i,j);
        printf("%d\n",total);            
    }
    return 0;
}

例题5：NYOJ 523(亡命逃窜)，没有多大改变，就是变成三维的了，没有什么要注意的，就是数据量比较大，用cin,cout会超时，改成scanf,printf输入输出就可以了。

#include<iostream>
#include<cstring>
#include<queue>
#include<cstdio> 
using namespace std;
const int MAX=51;
int A,B,C,Time,map[MAX][MAX][MAX];
int dx[6]={-1,0,1,0,0,0},dy[6]={0,1,0,-1,0,0},dz[6]={0,0,0,0,1,-1};
struct Point
{   int x,y,z,step;
    bool operator==(const Point& P) const
    {   return x==P.x&&y==P.y&&z==P.z; 
    } 
};
Point Start,End;
bool Inside(Point P)
{   return P.x>=0&&P.x<A&&P.y>=0&&P.y<B&&P.z>=0&&P.z<C;
}
int BFS()
{   queue<Point> Q;
    Point s,New;
    Q.push(Start);
    map[Start.x][Start.y][Start.x]=1; 
    while(!Q.empty())
    {   s=Q.front();
        Q.pop();
        if(s==End&&s.step<=Time) return s.step; 
        for(int i=0;i<6;i++)
        {   New.x=s.x+dx[i];
            New.y=s.y+dy[i];
            New.z=s.z+dz[i]; 
            if(Inside(New)&&map[New.x][New.y][New.z]==0)
            {   map[New.x][New.y][New.z]=1;
                New.step=s.step+1;
                Q.push(New); 
            }
        }
    }
    return 0;
}
int main()
{   int Case,flag;
    scanf("%d",&Case); 
    while(Case--)
    {   scanf("%d%d%d%d",&A,&B,&C,&Time);
        Start.x=0,Start.y=0,Start.z=0,Start.step=0;
        End.x=A-1,End.y=B-1,End.z=C-1; 
        for(int i=0;i<A;i++)
            for(int j=0;j<B;j++)
                for(int k=0;k<C;k++)
                {   scanf("%d",&flag);
                    map[i][j][k]=flag;
                }  
        flag=BFS();   
        if(flag) printf("%d\n",flag);
        else printf("-1\n"); 
    }
    return 0;
}

嗯，最后一个题型了，马的遍历，POJ 2243(马的遍历)，记住加visit[][]，剪枝防止超时，找到马的跳跃过程中坐标的变化情况即可。

#include<iostream>
#include<cstring>
#include<queue>
#include<cstdio>
using namespace std;
const int MAX=10;
#define CLR(arr,val) memset(arr,val,sizeof(arr))
int visit[MAX][MAX];
int dx[8]={-2,-1,1,2,2,1,-1,-2},dy[8]={1,2,2,1,-1,-2,-2,-1};
struct Point 
{   int x,y,step;
    bool operator==(const Point &P) const
    {   return P.x==x&&P.y==y;
    }
};
Point Start,End;
bool Inside(Point P)
{   return P.x>=1&&P.x<9&&P.y>=1&&P.y<9;
}
int BFS()
{   queue<Point> Q;
    Point s,New;
    Q.push(Start);
    while(!Q.empty())
    {   s=Q.front();
        Q.pop();
        if(s==End) return s.step;
        for(int i=0;i<8;i++)
        {   New.x=s.x+dx[i];
            New.y=s.y+dy[i];
            if(Inside(New)&&!visit[New.x][New.y])
            {   New.step=s.step+1;
                visit[New.x][New.y]=1; 
                Q.push(New);
            }
        }    
    }
}
int main()
{   char S[10],E[10];
    while(scanf("%s %s",S,E)!=EOF)
    {   CLR(visit,0);
        Start.x=S[0]-'a'+1,Start.y=S[1]-'0',Start.step=0;
        End.x=E[0]-'a'+1,End.y=E[1]-'0';
        visit[Start.x][Start.y]=1; 
        printf("To get from %s to %s takes %d knight moves.\n",S,E,BFS());
    }
    return 0;
}

 



 

xuzengqiang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
矩阵-斐波那契数列
许增强
06-08 1万+
利用矩阵来求解斐波那契数列的有关问题是ACM题中一个比较常见的题型。例：NYOJ 148(斐波那契数列2)。 有关斐波那契树列的规律详见这里。 (1)、对于n>1，都有f(n)与f(n-1)互质。 (2)、f(n)=f(i)*f(n-i-1)+f(i+1)*f(n-i)。 现在说说怎么利用矩阵来求解斐波那契数列。 我们可以先保存b=f(1),a=f(0)，然后每次设： b'=a+b a'
取石子游戏之巴什博弈
许增强
07-19 6856
下面这段来自白白の屋的文章的一段： 巴什博弈：只有一堆n个物品，两个人轮流从这堆物品中取物，规定每次至少取一个，最多取m个。最后取光者得胜。     显然，如果n=m+1，那么由于一次最多只能取m个，所以，无论先取者拿走多少个，后取者都能够一次拿走剩余的物品，后者取胜。因此我们发现了如何取胜的法则：如果 n=（m+1）r+s，（r为任意自然数，s≤m),那么先取者要拿走s个物品，如果
C++ bfs 迷宫问题
wfuzhuandaaliu的博客
01-09 670
输入一个二维数组表示迷宫，然后输入起始位置和要找到的位置，求其最短路径 地图样例 5 4 0 0 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 1 1 4 3 和dfs不同，bfs是基于队列实现的，每次把同一层次的搜完，然后再搜下一层的所有数，而不是一条路走到黑，迷宫问题bfs是优于dfs的，因为bfs只要首次找到终点，那路径必是最短路径，不用再像dfs一样全遍历完再比较。 其具体路径如下 首先先建个结构体，用来储存每一步的x,y和步数 struct node{ int x;
BFS走迷宫
m0_62881629的博客
05-31 1680
先来讲一下bfs（广度优先搜索）的理解和模扳； BFS(广度优先搜索) bfs是一个对连通图进行遍历的算法。它的思想是从一个被选定的点出发；然后从这个点的所有方向每次只走一步的走到底（即其中一个方向走完一步之后换下一个方向继续走）；如果得不到目的解，那就返回事先定好的值，如果找到直接返回目的解。 如图所示，从1开始搜，有2，3，4几个点，存起来，从2开始有5，6，存起来，搜3，有7，8，存起来，搜4，没有了；现在开始搜刚刚存的点，从5开始，没有，然后搜6.。。一直进行，直到找到； ...
java_迷宫BFS
青荣的博客
05-12 499
迷宫算法BFS import java.util.LinkedList; import java.util.Scanner; //迷宫BFS广度算法 public class maze_1 { static int[][] maze; static int x, y;//地图的大小 static int[] addx={-1,1,0,0};//x向量增加量 st...
BFS求解迷宫问题
Fizzoa的博客
01-29 3652
BFS求解迷宫问题
C++ BFS迷宫.cpp
03-26
C++ BFS迷宫.cpp
BFS搜索 迷宫.cpp
10-13
BFS搜索案例——走出迷宫。 广度优先搜索BFS（Breadth First Search）也称为宽度优先搜索，它是一种先生成的结点先扩展的策略。
C# 自动寻路迷宫（bfs）
06-15
1.随意设置起点位置 2.随意设置终点位置 3.随意设置障碍物 4.自动bfs寻路，地图上打印寻找的路径
广度优先搜索构建迷宫（BFS算法）动态构建过程_深度优先算法时间复杂度
11-23
广度优先搜索构建迷宫（BFS算法）动态构建过程的python 源代码，详情请移步本人博客<迷宫与寻路可视化（二）广度优先搜索构建迷宫（BFS算法）>
C++-VS2019-迷宫寻路BFS+DFS代码.zip
07-22
最终效果是实现了Prim随机生成迷宫，BFS&DFS路径显示、最短路长度显示、过程动态展示，主函数中有菜单，操作方便。 不仅可以用来读代码长知识、还可以用作算法演示。 附带第五版的exe文件，欢迎使用！
区间动态规划
许增强
08-14 6388
1、矩阵连乘，tyvj 1198(最优矩阵连乘)，关键是写出动态转移方程。用DP[i][j]表示矩阵Ai乘到Aj的最优解，P[]用来存储矩阵的行和列，M[i-1]表示矩阵i的行，M[i]表示矩阵i的列。 当i==j时，DP[i][i]=0； 当i(A3A4A5A6A7A8)A9。我们知道若A矩阵为r1*c的矩阵，A2为c*r2的矩阵，得到的将是一个r1*r2的矩阵，且连乘次数为r1*c*r2。
NYOJ 动态规划
许增强
08-14 2276
题1：NYOJ 10(滑雪)，前面的博文-动态规划中有。 题2：NYOJ 15(括号匹配)，放在区间动态规划中。 题3：NYOJ 16(矩阵嵌套)，大概意思给你n个矩阵，这些矩阵相互嵌套，问能够嵌套的最大个数，直接按长度从大到小排序，长度相等则按宽度从大到小排序，由于能够嵌套满足：长1DP[i]=max(DP[i],DP[j+1])(0 #include #include #inc
STL中map和priority_queue的应用
许增强
07-19 2211
基本的知识就不再讲了，只列下用map做的题目： 题1：POJ 1002(487-3279)，这个题目烦的死，TLE了n次,只是因为我用G++提交的，好啦，要注意的就是把数组开大点，和用c语言输入，最后如果没有重复的电话号码输出:No duplicates.。 #include #include #include #include #include #include using na
一些比较经典的题目和结论
许增强
04-20 1925
1、点P(x,y)绕点o(x0,y0)逆时针旋转a角度后的坐标为P'(x1,y1):       x1=(x-x0)*cosa-(y-y0)*sina+x0;  y1=(x-x0)*sina+(y-y0)*cosa+y0。 2、最大子矩阵和最大子段和模板，例题：NYOJ 1047和NYOJ 14,下面以NYOJ 104代码为例，我觉得也要注意一下讨论区的那组数据，不是输出0，而是-2。
位运算
许增强
05-28 1755
(1)、按位与(&)，将两个操作数化为二进制后并将对应的每一位分别进行逻辑与操作。(a%(2^n)=a&(2^n-1)) (2)、按位或(|)，将两个操作数化为二进制后并将对应的每一位分别进行逻辑或操作。 (3)、按位异或(^)，和以上同，异或是指对应位相同则运算结果为0，否则为1。 (4)、按位取反(~)，对每一位进行取反。(求x的相反数：x=(~x+1)) (5)、移位。分为左移(>)
取石子游戏之尼姆博弈
许增强
07-23 1214
尼姆博弈：有三堆各若干个物品，两个人轮流从某一堆取任意多的物品，规定每次至少取一个，多者不限，最后取光者得胜。 这种情况与二进制有着很大的关系，我们用(a,b,c)来表示某种局势，那么(0,0,0)必然为奇异局势，最后一个面对这个局势的必败。(0,n,n)也是种奇异局势。因为如果对手在其中一堆取m个石子(m 直接说结论吧： 对于任意的奇异局势(a,b,c)，都有a^b^c=0。(^为异或运算
取石子游戏之威佐夫博弈
许增强
07-20 1163
下面博文中有一部分是转载自ACM and JAVA的文章。 威佐夫博弈：有两堆各若干个物品，两个人轮流从某一堆或同时从两堆中取同样多的物品，规定每次至少取一个，多者不限，最后取光者得胜。 我们用(ak,bk)(ak局势。如果甲面对局势(0,0)，说明甲输了，我们把这种情况叫做奇异局势。 现在的问题我给你一个局势(a,b)，我们怎么判断它是不是奇异局势呢？ 判断公式为：ak=[k(1+√5)
BFS迷宫问题python
最新发布
12-02
以下是使用BFS算法解决迷宫问题的Python代码： ```python from queue import Queue # 定义迷宫地图 maze = [ [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] ] # ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值