BFS+DFS

已于 2022-03-06 23:30:57 修改
阅读量422 收藏
点赞数 1
分类专栏： 搜索 文章标签： 深度优先 宽度优先 算法
于 2021-12-11 21:41:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51070956/article/details/121879563
版权

DFS+BFS刷题日记

Catch That Cow

题意：
John在坐标n上，可以左移右移加跳跃，牛在坐标k上且不动，至少多久抓住牛

//#include<bits/stdc++.h>
#include<iostream>
#include<stdlib.h> 
using namespace std;
#include <queue>
#include <string.h>
const int MAXX=100000;
struct node{
	int x;
	int step;//这个点的位置是x，从出发点走了step步，一步一分钟
	node(int xx,int s):x(xx),step(s){} //这种构造方法 
	node(){}//空的构造函数，才允许node p 
};
//queue<node> a[MAXX+10];和vector不同 
queue<node> a;
int vis[MAXX+10];//给下标 设置判重标记，看看这个节点是否已经被扩展过 
int main(){
	ios_base::sync_with_stdio(0);
	int n,k;//John在坐标n上，可以左移右移加跳跃，牛在坐标k上且不动，至少多久抓住牛
	cin>>n>>k;
	memset(vis,0,sizeof(vis)); 
	node p;
	p.x=n;
	p.step=0;
	a.push(p);//第一步先把初始节点放入队列 
	vis[n]=1;
	while(!a.empty()){//队列不为空就逐一出队，并将出队的节点的邻接节点入队 
		node q=a.front();
		if(q.x==k){
			cout<<q.step<<endl;
			return 0;
		} 
		else{//若出队的节点为目标节点可以he了，若队列空了也没找到目标节点就be 
			if(q.x-1>=0&&!vis[q.x-1]) {
//				q.x=q.x-1;怎么重新创建一个匿名的node对象 
//				q.step=q.step+1;
				a.push(node(q.x-1,q.step+1)) ;
				vis[q.x-1]=1;
			}
				if(q.x+1<=MAXX&&!vis[q.x+1]) {
				a.push(node(q.x+1,q.step+1)) ;
				vis[q.x+1]=1;
			}
			if(2*q.x<=MAXX&&!vis[2*q.x]) {
				a.push(node(2*q.x,q.step+1)) ;
				vis[2*q.x]=1;
			}
			a.pop();
		}
	} 
    return 0;
}

6264:走出迷宫（BFS、DFS剪枝）

传送门
题意：假设你已经得到了一个n*m的迷宫的图纸，已知起点和终点坐标，请你找出从起点到出口的最短路。
BFS板子题

//#include<bits/stdc++.h>
#include<iostream>
#include<stdlib.h> 
using namespace std;
#include <queue>
#include <string.h>
int m,n;
int ex,ey;
struct node{
	int x;
	int y;
	int step;
	node(int xx,int yy,int steps):x(xx),y(yy),step(steps){};
};
char a[105][105];
int vis[105][105];
int dx[4]={-1,1,0,0};//上下左右 
int dy[4]={0,0,-1,1};
int main(){
	ios_base::sync_with_stdio(0);
	queue<node> q;
	cin>>m>>n;
	for(int i=0;i<m;i++){
		cin>>a[i];
	}
	memset(vis,0,sizeof(vis));
	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){
			if(a[i][j]=='S'){
				q.push(node(i,j,0));
				vis[i][j]=1;
			}
			if(a[i][j]=='T'){
				ex=i; 
				ey=j;
			}
		}
	}
	while(!q.empty()){
		node p=q.front();
		if(p.x==ex&&p.y==ey){
			cout<<p.step<<endl;
			return 0;
		}
		else{
//			if(p.x+1<m&&p.y+1<n&&!vis[p.x+1][p.y+1])
		for(int i=0;i<4;i++){
	 		int cx=p.x+dx[i];
	 		int cy=p.y+dy[i];
	 		if(cx>=0&&cx<m&&cy>=0&&cy<n){
	 			if(!vis[cx][cy]&&a[cx][cy]!='#'){
	 				q.push(node(cx,cy,p.step+1));
	 				vis[cx][cy]=1;
//少了就6分 感觉像DFS中的剪枝，但 dfs不剪枝会tle可是这个会memory LImit Exceeded 
				 }
			 }
		 }
		q.pop();
	 }
}
    return 0;
}

int lastminL[105][105];
时间换空间，剪枝来了，dfs要逐一走很多条路
且每条路都走到终点罢休所以超时，而且每次都只单独存储正在走的这一条路
不知道别的路情况怎么样，比如走到同一个点a[i][j],上一条路用了x步，
这条路用了y步，那这条路自然就不继续走下去了，return。但由于只
单独存储一条路，无法与别的路进行比较，因此空间换时间，用这个数组lastminL[i][j]
记录之前走的若干条路走到a[i][j]时用的最小步数，如果再走一条路走到这个点，用的
步数超过了 lastminL[i][j]，那么这条路就不用走了
就像寻路问题ROADS那题(找最短路径)，也开了一个数组minL[i][j]表示从1走到城市i
且经费还剩j时所走的长度，如果后续的路上恰好走到i剩j钱且走的路长于minL[i][j]就不走了
还有一个剪枝条件，（最优性剪枝和可行性剪枝，暂时对不上号）
就是也许有的路已经走完得到结果需要走minx这么长，可这条路某阶段已经超过minx就pass

对了还有一个值得注意的地方就是设置无穷大的值的时候，一会儿１＜＜３０，一会儿０ｘ３ｆ３ｆ３ｆ
这样就会出问题噢
step　既与　lastminL[x][y]（初始化为１＜＜３０）比较
又与ｍｉｎｘ（初始化为　０ｘ３ｆ３ｆ３ｆ）比较
虽然我还没扪清到底哪一步　让ｍｉｎｘ与lastminL[x][y]间接比上了

#include <bits/stdc++.h>		
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
int m,n; 
char a[105][105];
	int ps,qs,pe,qe;
int minx=1<<30;//也可以用1<<30;这种形式表示一个很大的数 
int dx[4]={-1,1,0,0};//上下左右 
int dy[4]={0,0,-1,1};
int vis[105][105];
//int step=-1; 
int lastminL[105][105];//到上次路为止走到a[i][j]用的最少步数（比出来的） 
void dfs(int x,int y,int step){//第x行，第y列 
	 if(vis[x][y])return;
	 if(step>=minx)return;
		 if(step>=lastminL[x][y])return;
		 else lastminL[x][y]=step;//lastminL[i][j]是逐一比较更新出来的 
	 		vis[x][y]=1;
	 		if(x==pe&&y==qe){
	 			minx=min(minx,step);
//dfs是每一条路径都走遍了才确定找出最小的step 
	 			return;
			 }
	 	for(int i=0;i<4;i++){
//	 		step=kkk;//dfs没有搜到是要回溯的。。。回到原来的step,每次step--也行 
	 		int cx=x+dx[i];
	 		int cy=y+dy[i];
	 		if(cx>=0&&cx<m&&cy>=0&&cy<n){
	 			if(!vis[cx][cy]&&a[cx][cy]!='#'){
	 				dfs(cx,cy,step+1);
//				 step--; 回溯回来不仅要考虑还原step，还有vis数组 
					vis[cx][cy]=0; //加上这条，果然就tle了，这才是dfs硬解这题的反应
//		so 接下来应该剪枝！how to do 
				 }
			 }
		 }
}
int main(){
	
	cin>>m>>n;
	for(int i=0;i<m;i++){
		cin>>a[i];
	}
	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){
			lastminL[i][j]=(1<<30); 
		}
	} 
	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){
			if(a[i][j]=='S'){
				ps=i; 
				qs=j;
			}
			if(a[i][j]=='T'){
				pe=i; 
				qe=j;
			}
		}
	}
	memset(vis,0,sizeof(vis));
	dfs(ps,qs,0);
	cout<<minx;
    return 0;
}

保留注释部分是为了更好地与没剪枝的样子对比
下面是没剪枝的ｔｌｅ代码

#include <bits/stdc++.h>		
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
int m,n; 
char a[105][105];
	int ps,qs,pe,qe;
int minx=0x3f3f3f3f;//也可以用2<<30;这种形式表示一个很大的数 
int dx[4]={-1,1,0,0};//上下左右 
int dy[4]={0,0,-1,1};
int vis[105][105];
int step=-1; 
void dfs(int x,int y){//第x行，第y列 
	 if(vis[x][y])return;
	 else{
	 		vis[x][y]=1;
	 		step++;
	 		if(x==pe&&y==qe){
	 			minx=min(minx,step);
//dfs是每一条路径都走遍了才确定找出最小的step 
	 			return;
			 }
		int kkk=step;
	 	for(int i=0;i<4;i++){
	 		step=kkk;//dfs没有搜到是要回溯的。。。回到原来的step 
	 		int cx=x+dx[i];
	 		int cy=y+dy[i];
	 		if(cx>=0&&cx<m&&cy>=0&&cy<n){
	 			if(!vis[cx][cy]&&a[cx][cy]!='#'){
	 				dfs(cx,cy);
//					 step--; 回溯回来不仅要考虑还原step，还有vis数组 
					vis[cx][cy]=0; //加上这条，果然就tle了，这才是dfs硬解这题的反应
//		so 接下来应该剪枝！how to do 
				 }
			 }
		 }
	 }
}
int main(){
	cin>>m>>n;
	for(int i=0;i<m;i++){
		cin>>a[i];
	}

	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){
			if(a[i][j]=='S'){
				ps=i; 
				qs=j;
			}
			if(a[i][j]=='T'){
				pe=i; 
				qe=j;
			}
		}
	}
	memset(vis,0,sizeof(vis));
	dfs(ps,qs);
	cout<<minx;
    return 0;
}

1159:Maze(BFS不止一次，没有限制的BFS一次可以遍历所有节点，一旦对某些节点加以限制，那么限制的节点可以到达却不入队，它的拓展节点自然不能通过它被访问到更别提入队，一次BFS之后再判断限制的节点能否入队，入队之后，以该限制节点为起始节点BFS

题意：A—E五道门，迷宫中有几把对应的钥匙a—e(A对应a）就需要集齐所有的钥匙才能开对应的这道门，问从起始点能否到达终点（终点可能被门或墙围拦住，导致BFS永远遍历不到

#include<iostream>
#include <string.h>
#include <queue>
using namespace std;
const int maxn=40;
struct Node{
    int x,y;
    Node() {}
    Node(int xx,int yy){
        this->x=xx;
        this->y=yy;
    }
 
};
//钥匙/门的哈希值相同 通过门的哈希值找到对应的钥匙  A a
struct Door{
    int num;   //总共数量
    int sum;  //遇到的数量
}door[maxn];
 
queue<Node> Q;
char G[maxn][maxn];
int n,m;
int vis[maxn][maxn],vis_door[maxn];
const int go[][2]={1,0,
                   -1,0,
                   0,1,
                   0,-1};
void init(){
    while(!Q.empty()) Q.pop();
    memset(vis,0,sizeof(vis));
    memset(vis_door,0, sizeof(vis_door));
    for(int i=0;i<maxn;i++){
        door[i].num=0;
        door[i].sum=0;
    }
}
 
void read(){
    //从1开始读入
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            cin>>G[i][j];
            if(G[i][j]>='a' && G[i][j]<='e'){
                door[G[i][j]-'a'].num++;   //hash
            }
            else if(G[i][j]=='S'){
                vis[i][j]=1;
                Q.push(Node(i,j));
            }
        }
 
    }
 
}
 
bool inside(int x,int y){
    return x>=1 && x<=n && y>=1 && y<=m ;
}
void BFS(){
    bool f=true;
    while(f){
        //bfs + 标记门和钥匙
        while(!Q.empty()){
            //如果出口
            Node cur=Q.front(); Q.pop();
            int x=cur.x,y=cur.y;
            if(G[x][y]=='G'){
                cout<<"YES"<<endl;
                return;
            }//终点这个节点能否入队 
 
            for(int i=0;i<4;i++){//对队列中的节点进行扩展 
                int xx=x+go[i][0];
                int yy=y+go[i][1];
                if(inside(xx,yy) && G[xx][yy]!='X' ){
                    char c=G[xx][yy];
                    if(vis[xx][yy]) continue;
                    //钥匙
                    else if(c>='a' && c<='e'){
                        door[c-'a'].sum++;
                    }
                    else if(c>='A' && c<='E'){
                        vis_door[c-'A']=1;
                        continue; //注意这个位置  队列里加入的到底是啥
                    }
                    vis[xx][yy]=1;
                    Q.push(Node(xx,yy));//除了墙和门不能入队，哪怕是终点也可以直接入队，如果在碰见门之前碰见了终点，直接入队，BFS说明 终点比门离起点更近 
                }
            }//出队并对出对元素进行拓展（看情况让拓展的元素入队） 
 
        }//完成了一轮BFS，队列已经为空了，终点没进过队，要么是被墙挡住了要么是被门挡住了 
        f=false;
        //检查门能不能开 vis_door
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(G[i][j]>='A' && G[i][j]<='E' && !vis[i][j] ){
                    char c=G[i][j];
                    int id=c-'A';
                    if(vis_door[id] && door[id].num>0 && door[id].num==door[id].sum){
                        vis[i][j]=1;
                        Q.push(Node(i,j));//是被门挡住了且钥匙已经集齐，将门入队，那么再一轮BFS(从队列队首元素开始，如果终点是被门挡住的，终点就会作为该门的拓展节点入队 
                        f= true;
                    }
                }
            }
 
        }
 
    }
    cout<<"NO"<<endl;//要么是被墙挡住的，要么是被门挡住的但是没集齐钥匙
//	？万一钥匙离起点更远，到了门还没到钥匙呢？（那么钥匙就永远到不了的） 
//不存在的，只要钥匙四周有能被扩展的点那么一次BFS就一定能将钥匙入队，
//除非钥匙被墙、门包围了，那这种情况下的没集齐钥匙（没集齐钥匙只会是这种情况 ）
//就永远不可能集得齐 

 
//BFS的特点，BFS扩展完一轮其实是可以将所有的节点都走一遍的，只是有些节点不允许
//入队，那么它的扩展节点 嘿，也不一定不能入队，如果它的扩展节点也是别的能扩展的扩展节点
//如果一个节点不能被到达（到达了却不允许入队的也算是到达了），那一定是它周围的节点
//都能被到达，却都不能入队，导致该节点不能被扩展入队 
//我感觉我又可以了 
//之前做的题其实都是在一遍BFS过程中完成的，一次BFS所有的点都可以到达并入队
}
 
int main(){
    while(cin>>n>>m && (n&&m)){
        init();
        read();
        BFS();
    }
    return 0;
}

自己再来一遍

 #include<bits/stdc++.h>
using namespace std;
int m,n;
char a[25][25];
int dx[4]={1,-1,-0,0};
int dy[4]={0,0,1,-1};
struct node{
	int x;
	int y;
	node(int xx,int yy):x(xx),y(yy){};
};
struct door{
	int num;//对于这扇门共有多少把钥匙 
	int sum; //对于这扇门集齐了多少把钥匙 
}door[5];
queue<node> q;
int vis_door[5];//终点不能入队，记录是不是门挡住的 
int vis[25][25];
void bfs(){
	int flag=true;
	while(flag){
			while(!q.empty()){//开始来一次bfs全扫一遍 
		node p=q.front(); q.pop();//放在循环体中的最后一条也行 
		 if(a[p.x][p.y]=='G'){
		 	cout<<"YES"<<endl;
		 	return ;//顺利找到终点，没有受到门和墙的阻拦 
		 } 
		 else{
		 	for(int i=0;i<4;i++){
					int cx=p.x+dx[i];
					int cy=p.y+dy[i];
					if(cx>=0&&cx<m&&cy>=0&&cy<n&&!vis[cx][cy]){
						if(a[cx][cy]=='X')continue;//到达过但不入队，不能通过它到达它的扩展节点
						else if(a[cx][cy]>='a'&&a[cx][cy]<='e'){
							door[a[cx][cy]-'a'].sum++;
							//记录找到的钥匙，这个节点是要入队的，不能用 continue； 
						} 
						else if(a[cx][cy]>='A'&&a[cx][cy]<='E') {
							vis_door[a[cx][cy]-'A']=1;
							continue;//门是不能直接入队的 
						}
						vis[cx][cy]=1;
						q.push(node(cx,cy));
					}
			 }
		 } 
	}//一次bfs结束了，如果到达了终点会return，否则还要看看终点没入队是不是被门
//挡住了，如果门能开那还有到达终点的希望，将门入队（即以门为起始节点再进行BFS扩展 
 	flag=false;
	 for(int i=0;i<m;i++){//来看看有没有找齐钥匙的门 
	 	for(int j=0;j<n;j++){
	 		if(a[i][j]>='A'&&a[i][j]<='E'&&!vis[i][j]){
	 			if(vis_door[a[i][j]-'A']&&door[a[i][j]-'A'].num==door[a[i][j]-'A'].sum){
	 				flag=true;
	 				vis[i][j]=1;
	 				q.push(node(i,j));
				 }
			 }
		 } 
	 } //如果没有一扇门能打开看看能否拓展到终点,就be了 
//	  if(!flag)cout<<"NO"<<endl; flag不能重新被赋值true自然不能再BFS就输出no啦 
	}
		cout<<"NO"<<endl; 
}
int main(){
	ios_base::sync_with_stdio(0);
	while(cin>>m>>n){
		if(m==0&&n==0)return 0;
		
		while(!q.empty())q.pop();
		memset(vis,0,sizeof(vis));
		memset(vis_door,0,sizeof(vis_door));
		for(int i=0;i<5;i++){
			door[i].num=0;
			door[i].sum=0;
		}//因为有多组数据，一定要完完整整地全盘初始化 
		for(int i=0;i<m;i++){
			for(int j=0;j<n;j++){
				cin>>a[i][j];
				if(a[i][j]=='S'){
//					sx=i; sy=j;
				q.push(node(i,j));//将起始节点入队了 
				vis[i][j]=1; 
				}
				if(a[i][j]>='a'&&a[i][j]<='e'){//累计有多少把钥匙 
					door[a[i][j]-'a'].num++; 
				}
			}
		} 
		bfs(); 
	}
    return 0;
}

TLE，问题在于vis数组的置1 和 push入队 是否被忘记
第一次BFS，但凡不是墙，不是门，且！vis[i][j]没被拓展进队过，就应该push进队且勿忘vis【i】【j】置1
第一次BFS没能到达目标点，之后要看目标点没能入队的原因是被墙拦住了（没救了）还是被门拦住了（有希望，如果到达过该门且现在该门对应的钥匙集齐了，就应该将该门入队展开BFS，同时由于该门入队了，vis【i】【j】要置为1，判断是否入队时忘记了**！vis【i】【j】**这个条件
第一次BFS到达了门却不管钥匙情况，一概不让门入队，应为要等BFS走完所有能走的地方收集完所有能收集的钥匙之后才能确保一扇门是否能被打开。
由于没有保留所有门的坐标，还需要从a迷宫数组中去找门，会找到所有的门并把全部能开的门都入队，届时就可以通过这些点为中心BFS，万一通过　第一次找到能入队的门　还是不能到达终点，但是可能集齐了另外的钥匙能进入上次开不了的门，所以要再遍历ａ迷宫数组去找能开的门，这时就要避免被上次开过的门蒙蔽了，上回开过且没找到，又通过这扇门去BFS，时间就耗在这儿了，所以开过的门（入过队的门也要标记ｖｉｓ【ｉ】【ｊ】为１，下次得有别的新的门能够打开才有希望寻到新的地方（也许存在目标点）
逻辑有点多，遵循规则就好，凡是入队过（BFS拓展过的节点，ｖｉｓ【ｉ】【ｊ】统统置为１，找能否入队的点也一定要判断　！ｖｉｓ【ｉ】【ｊ】，避免重复入队，这个节点能BFS到的范围已经考虑过了，再寻无意义，不会有新发现。

6044:鸣人和佐助

6044:鸣人和佐助

一开始一个不小心被提示：
每个节点ckl的状态可能会发生改变，对于判重数组，原来的vis数组----->开一个三维数组来存放所有状态的标志位
这题相比于走迷宫的题，多了一个查克拉ckl的数目。从初始状态到目标状态至少要多少步？走迷宫那道题的状态就是位置的坐标，这题的状态可视作三维的，如果在同一个点拥有着不同的查克拉数量也视作不同的状态，后续到达的点走过的路会不一样。
接着按照BFS套路一通做也AC了，可见套路不变。
但是判重的过程中有些想不通，有的节点是多次入队拓展的，与传统bfs的判重规则不一样，也没想到有什么情况需要重新扩展一次某节点。

 #include<bits/stdc++.h>
using namespace std;
int r,c,k;
char a[202][202];
int vis[202][202][15];
int dx[4]={1,-1,0,0};
int dy[4]={0,0,-1,1};
struct node{
	int x;
	int y;
	int step;
	int ckl;
	node(int i,int j,int k,int tt):x(i),y(j),ckl(k),step(tt){};
};
queue<node> Q;
void bfs(){
	while(!Q.empty()){
		node p=Q.front();Q.pop();
		int xx=p.x;
		int yy=p.y;
		if(a[xx][yy]=='+'&&p.ckl>=0){
			cout<<p.step<<endl;
			return ;
		}
		 else{
//		 	if(p.ckl<=0){
//		 		cout<<"-1"<<endl;
//		 		return ;草率了，说不定周边没有#呢，还是得bfs结束，队列为空仍然没找到+ 
//			 }
		 	for(int i=0;i<4;i++){
		 		int x=xx+dx[i];
		 		int y=yy+dy[i];
		 		if(x>=0&&x<r&&y>=0&&y<c){
		 			
		 			if(a[x][y]=='#'){
		 				if(p.ckl<=0)continue;
		 				if(vis[x][y][p.ckl-1])continue;
		 				else{
		 					Q.push(node(x,y,p.ckl-1,p.step+1));
		 					vis[x][y][p.ckl-1]=1;
						 }
					}
		 			else {
		 				if(vis[x][y][p.ckl])continue;
		 				else{
		 					Q.push(node(x,y,p.ckl,p.step+1));
		 					vis[x][y][p.ckl]=1;
						 }

					 }
				 }
			 }
		 }
	}
		 cout<<"-1"<<endl;
}
int main(){//r,c,k数据范围很大设置标志数组可能会超内存 
	ios_base::sync_with_stdio(0);

	cin>>r>>c>>k;
	memset(vis,0,sizeof(vis));
	 for(int i=0;i<r;i++){
	 	for(int j=0;j<c;j++){
	 		cin>>a[i][j];
	 		if(a[i][j]=='@'){
	 			Q.push(node(i,j,k,0));
	 			vis[i][j][k]=1;
			 }
		 }
	 }
	 bfs();

    return 0;
}

于是又按老套路做了一遍，以5分wa了

 #include<bits/stdc++.h>
using namespace std;
int r,c,k;
char a[202][202];
int vis[202][202];
int ckl[202][202]; 
int dx[4]={1,-1,0,0};
int dy[4]={0,0,-1,1};
struct node{
	int x;
	int y;
	int step;
//	int ckl;
	node(int i,int j,int tt):x(i),y(j),step(tt){};
};
queue<node> Q;
void bfs(){
	while(!Q.empty()){
		node p=Q.front();Q.pop();
		int xx=p.x;
		int yy=p.y;
		if(a[xx][yy]=='+'&&ckl[xx][yy]>=0){//&&ckl[xx][yy]>=0
			cout<<p.step<<endl;
			return ;
		}
		 else{
//		 	if(p.ckl<=0){
//		 		cout<<"-1"<<endl;
//		 		return ;草率了，说不定周边没有#呢，还是得bfs结束，队列为空仍然没找到+ 
//			 }
		 	for(int i=0;i<4;i++){
		 		int x=xx+dx[i];
		 		int y=yy+dy[i];
		 		if(x>=0&&x<r&&y>=0&&y<c){
		 			
		 			if(a[x][y]=='#'){
		 				ckl[x][y]=ckl[xx][yy]-1;
		 				if(ckl[x][y]<0)continue;//可以等于0噢 if(ckl[xx][yy]<=0)continue;
		 				if(vis[x][y])continue;
		 				else{
		 					Q.push(node(x,y,p.step+1));
		 					vis[x][y]=1;
						 }
					}
		 			else {
		 				ckl[x][y]=ckl[xx][yy];
		 				if(ckl[x][y]<0)continue;
		 				if(vis[x][y])continue;
		 				else{
		 					Q.push(node(x,y,p.step+1));
		 					vis[x][y]=1;
						 }

					 }
				 }
			 }
		 }
	}
		 cout<<"-1"<<endl;
}
int main(){//r,c,k数据范围很大设置标志数组可能会超内存 
	ios_base::sync_with_stdio(0);

	cin>>r>>c>>k;
	memset(vis,0,sizeof(vis));
		memset(ckl,0,sizeof(ckl));
	 for(int i=0;i<r;i++){
	 	for(int j=0;j<c;j++){
	 		cin>>a[i][j];
	 		if(a[i][j]=='@'){
	 			Q.push(node(i,j,0));
	 			ckl[i][j]=k;
	 			vis[i][j]=1;
			 }
		 }
	 }
	 bfs();

    return 0;
}

而且有一个测试案例明明可以到达终点却返回了-1，说明终点没能成功入队呀。回顾三维判重数组的问题，某位置的节点是可以重复入队扩展的，什么样的节点呢？只是查克拉数目变了就可以再次入队，当然是查克拉数目在该点变多 才可能继续走下去，那某位置的节点查克拉数目怎么会增大呢？
一开始我构想，从节点a出发，到达拓展节点bs，如果b是#，查克拉数目减一，如果b是’.’，查克拉数目不变，那么接下来就算继续拓展又到达了a那么查克拉数量也一定不会大于a原来的ckl’数量呀
这么想就狭隘了

回顾一下，BFS是一次记录所有的路，所以需要设置判重标志来避免从多条路都到达 a
节点导致每次都重复去拓展a节点，归根结底判重标记就是判断从不同的路走到a节点需不需要从a节点拓展。那么这道题中，从不同的路到达a节点时查克拉的数量就很多样了，因为在不同的路中途碰见的# 数目不同，所以可能到达a节点时ckl数目不同，那么第一条路走到a节点时，路径时最短的，但查克拉剩余数量不一定是最多的，可能遇到了很多# ，此时a节点第一次入队拓展，但当从另一条更远的路走到a节点可能遇到的# 比最短的路要少且剩余ckl数目更多时，要继续从a节点出发寻找路径

就是说，bfs是多条路同时推进的，但是一般情形是最先到达x节点的那条路将x节点标记为到过，别的路就不再考虑这个节点了
但是这题不止最短路一个限制条件，还要考虑查克拉，可能别的路到达x节点时的查克拉不同（不同的所有情况里就包含了大于最先到x那条路到达x时的查克拉数，小于自然会筛掉），这时节点x要再次入队

Selvaggia
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
走出迷宫
KDKDBBY的博客
10-19 2071
描述 当你站在一个迷宫里的时候，往往会被错综复杂的道路弄得失去方向感，如果你能得到迷宫地图，事情就会变得非常简单。  假设你已经得到了一个n*m的迷宫的图纸，请你找出从起点到出口的最短路。 输入 第一行是两个整数n和m(1 接下来n行，每行一个长为m的字符串，表示整个迷宫的布局。字符'.'表示空地，'#'表示墙，'S'表示起点,'T'表示出口。 输出 输出从起点到出口最少
BFS和DFS
扮猪吃老虎二号的博客
08-29 165
一、前言 我们首次接触 BFS 和 DFS 时，应该是在数据结构课上讲的 “图的遍历”。还有就是刷题的时候，遍历二叉树我们会经常用到BFS和DFS。 二、区别 广度优先搜索算法（Breadth-First-Search，缩写为 BFS），是一种利用队列实现的搜索算法。简单来说，其搜索过程和 “湖面丢进一块石头激起层层涟漪” 类似。 深度优先搜索算法（Depth-First-Search，缩...
POJ 7218:献给阿尔吉侬的花束（广搜模板题）
Ctrl AC的博客
12-24 265
题目：忘题戳这 废话：开始写搜索题的时候不知道用dfs还是bfs，现在终于懂了一点点点点。 资料：dfs与bfs区别 题目就不念了，直接上模板： #include<iostream> #include<queue> #include<cstring> using namespace std; struct node { int r, c, step; };//存入队列的位置和步数 char map[210][210];//地图 int visit[210][2
6264:走出迷宫 （BFS，板子题）
weixin_46433162的博客
09-11 696
描述 当你站在一个迷宫里的时候，往往会被错综复杂的道路弄得失去方向感，如果你能得到迷宫地图，事情就会变得非常简单。 假设你已经得到了一个n*m的迷宫的图纸，请你找出从起点到出口的最短路。 输入 第一行是两个整数n和m(1<=n,m<=100)，表示迷宫的行数和列数。 接下来n行，每行一个长为m的字符串，表示整个迷宫的布局。字符’.‘表示空地，’#'表示墙，'S’表示起点,'T’表示出口。 输出 输出从起点到出口最少需要走的步数。 样例输入 3 3 S#T .#. … 样例输出 6 题目链接 思路
OpenJudge超详细题解，动画图文题解
热门推荐
07-05 3万+
内容来源于微信公众号：大神编程。已经过原文作者授权。 更新时间：2020-7-5 因为OpenJudge题库和一本通题库很多题都是一样，所以很多链接都是直接使用一本通的题解，完全不影响。 为什么要转载： 动画、图文结合。 我看了部分文章，一些我觉得很简单的题，但从中学到了以前没有学过的知识点和细节，重点是从中学习别人思维方式。 让更多的同学能学到更多的知识。 官方的QQ群：893157498 这是我建的QQ群：795233394 欢迎各位志同道合的同学们^_^ 已更新的题目颜色是蓝色，点击相
BFS-剪枝走迷宫问题【迷宫与宝藏-OJ1646】
zujiasheng的博客
01-22 724
参考博客 https://blog.csdn.net/qq_34542903/article/details/51100015     题目描述 机器人要在一个矩形迷宫里行动（不能原地停留，只能走向上/下/左/右），每移动一格花费1个单位时间。 迷宫有以下几种元素： 【*】 机器人的起点 【#】 墙。机器人不能走过这些格子 【.】 平地。 机器人可以在上面自由行走 【0-9】 宝藏。...
C++-VS2019-迷宫寻路BFS+DFS代码.zip
07-22
最终效果是实现了Prim随机生成迷宫，BFS&DFS路径显示、最短路长度显示、过程动态展示，主函数中有菜单，操作方便。 不仅可以用来读代码长知识、还可以用作算法演示。 附带第五版的exe文件，欢迎使用！
bfs-dfs.rar_BFS algoritm_BFS+c++
09-22
标题 "bfs-dfs.rar_BFS algoritm_BFS+c++" 指示了这个压缩包包含的是关于广度优先搜索（BFS）算法的实现，且是用C++编程语言编写的。描述 "bfs ,dfs algoritm in TC" 表明该算法在文本编辑器或编译器如Turbo C中进行...
Floyd算法求任意两点间的最短距离+BFS+DFS
08-08
用邻接矩阵来存储图，Floyed算法求任意两点间的最短路径并输出，广度优先遍历，深度优先遍历
二叉树遍历BFS与DFS详细代码python版
01-18
二叉树遍历BFS与DFS详细代码python版
算法之BFS与DFS
10-19
提供的压缩包文件包含了多个关于BFS和DFS的讲解资料，如"关于bfs与dfs.pdf"、"07_ACM_DFS+BFS.ppt"、"搜索(BFS_和_DFS).ppt"和"ACM算法设计-BFS(广度搜索)-DFS入门(深度搜索)详解.ppt"。这些资源详细介绍了这两种...
钰的BFS的学习笔记
CSY94CFY的博客
12-18 164
BFS（Breadth First Search） 什么是用BFS？ 为什么用BFS？ 怎么用BFS？ 例题： Description 定义一个二维数组： 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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的
广度优先算法走出迷宫
weixin_30335575的博客
11-16 90
广度优先算法（Breadth-First Search），同广度优先搜索，又称作宽度优先搜索，或横向优先搜索，简称BFS，是一种图形搜索演算法。简单的说，BFS是从根节点开始，沿着树的宽度遍历树的节点，如果发现目标，则演算终止。广度优先搜索的实现一般采用open-closed表。 有这么一个迷宫: 6 5 0 1 0 0 0 0 0 0 1 0 0 1 0 1 0 1 1 1 0 0 0 1 0 ...
走出迷宫、迷宫问题（思路讲解、模板）【深度优先搜索】
XJHui
03-16 4838
走出迷宫 题目链接（点击） 当你站在一个迷宫里的时候，往往会被错综复杂的道路弄得失去方向感，如果你能得到迷宫地图，事情就会变得非常简单。 假设你已经得到了一个n*m的迷宫的图纸，请你找出从起点到出口的最短路。 输入 第一行是两个整数n和m(1≤n,m≤100)，表示迷宫的行数和列数。 接下来n行，每行一个长为m的字符串，表示整个迷宫的布局。字符‘.’表示空地，‘#’表示墙，‘S’表示起...
1254：走出迷宫
weixin_39586087的博客
01-31 830
拿前面的题代码改改就行了。。这种题目就那么几个地方能挖空    #include &lt;algorithm&gt; #include &lt;iostream&gt; #include &lt;sstream&gt; #include &lt;cstdlib&gt; #include &lt;cstring&gt; #include &lt;cstdio&gt; #include &lt;s...
6264:走出迷宫
weixin_34377065的博客
05-20 119
总时间限制:1000ms 内存限制:65536kB描述 当你站在一个迷宫里的时候，往往会被错综复杂的道路弄得失去方向感，如果你能得到迷宫地图，事情就会变得非常简单。假设你已经得到了一个n*m的迷宫的图纸，请你找出从起点到出口的最短路。 输入第一行是两个整数n和m(1<=n,m<=100)，表示迷宫的行数和列数。接下来n行，每行一个长为m的字符串，表示整个迷宫的布局。...
OJ 1017:走出迷宫
BJUT_bluecat的博客
04-01 961
1017:走出迷宫 查看 提交 统计 提问 总时间限制: 1000ms 内存限制: 65536kB 描述 当你站在一个迷宫里的时候，往往会被错综复杂的道路弄得失去方向感，如果你能得到迷宫地图，事情就会变得非常简单。 假设你已经得到了一个n*m的迷宫的图纸，请你找出从起点到出口的最短路。 输入 第一行是两个整数n和m(1<=n,m<=100)，表示迷宫的...
岛屿个数（dfs)
最新发布
初九·潜龙勿用的博客
04-07 5125
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值