回溯法、分枝限定法--求解迷宫最近距离

最新推荐文章于 2022-02-12 17:34:21 发布
最新推荐文章于 2022-02-12 17:34:21 发布
阅读量527 收藏 6
点赞数 1
分类专栏： 算法 c 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48566899/article/details/121775318
版权
c 同时被 2 个专栏收录
57 篇文章 1 订阅
订阅专栏
算法
17 篇文章 3 订阅
订阅专栏

广度优先算法思路
在这里插入图片描述
在这里插入图片描述

在一个游戏中，玩家处于一个如下所示12行12列的迷宫：

0,1,0,0,0,1,1,1,0,1,0,1

0,0,0,1,0,0,0,0,1,0,0,1

0,1,0,1,0,1,1,1,0,1,0,0

0,1,0,0,0,0,0,1,0,0,1,1

0,0,0,0,1,0,0,0,0,0,0,0

0,0,1,0,0,0,1,0,0,0,1,0

0,0,1,0,0,0,0,0,1,0,0,0

1,0,0,1,0,1,0,0,0,1,0,1

0,0,1,0,1,0,1,0,1,0,0,0

0,0,0,0,0,1,0,0,0,1,1,0

0,0,0,0,0,1,0,0,0,0,0,0

0,1,0,1,0,0,0,1,0,1,0,0

其中迷宫由0,1组成，0表示道路，1表示障碍物。

现在要根据玩家和游戏中被攻击的虚拟boss所在位置，给玩家以最近距离的提示。

最近距离：
即玩家走到boss所走的最少步数。（注：路线中的一步是指从一个坐标点走到其上下左右相邻坐标点。）

输入格式:
输入4个整数a,b,c,d（即玩家和虚拟boss在迷宫中的坐标位置分别为(a,b) 、(c,d)）， 其中
0<=a,b,c,d<12。

输出格式:
输出在迷宫中从(a,b)出发到达(c,d)的最少步数，如果(a,b)永远无法到达(c,d)则输出10000。

输入样例:
在这里给出一组输入。
例如： 0 0 11 11 结尾无空行

输出样例:
在这里给出相应的输出。
例如：
22

回溯特别容易超时（尤其迷宫扩大后），可以按一般广搜（即用先进先出队列的广搜）或A*算法（优先队列式分枝限界法，简称优先队列式广搜）去改写。

回溯法：


#include<iostream>
using namespace std;
int mg[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}
};
int n,a,b,c,d,Min,step;
int offset[4][2]={{1,0},{-1,0},{0,1},{0,-1}};

int jianzhi(int x,int y,int i)
{
	int x1=x+offset[i][0],y1= y+offset[i][1];
	if(x1<0 || x1>8 || y1<0 || y1>8) return 0;
	if(mg[x1][y1]) return 0;
	if(step>Min)  return 0;
	return 1;
}

void f(int x,int y)
{//回溯最大的缺点，运算量难以控制 
	if(x==c && y==d)
	{
	   if(step-1<Min) Min=step-1;		
	}
	else for(int i=0;i<4;i++)
	  if(jianzhi(x,y,i))
	  {	 int x1=x+offset[i][0],y1= y+offset[i][1];	 
	  	 mg[x1][y1] = step;
	  	 step++;
	  	 f(x1,y1);
	  	 mg[x1][y1] = 0;
	  	 step--;
	  }
}

int main()
{
	cin>>n;
	while(n--)
	{
		cin>>a>>b>>c>>d;
		Min=100;
		step=1;
		f(a,b);	
		cout<<Min<<endl;	
	}
	
	return 0;
}

例如：
左上角（0，0）
起点（0，3）-> 终点 (2,2)

在这里插入图片描述
一般队列式分支限界算法搜索过程中生成的解空间树（前4层结点）为：【结点内数据：坐标(i，j), 根到当前结点已走步数step（代价）】
在这里插入图片描述
优先级队列式分支限界算法搜索过程中生成的解空间树（前4层结点）为：【结点内数据：坐标(i，j), 根到当前结点已走步数step（代价），当前结点到目标评估代价len】在这里插入图片描述

广搜（即用先进先出队列的广搜）


#include<iostream>
#include<memory.h>
#include<queue>
using namespace std;
int mg[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}
};
int n,a,b,c,d,m[9][9];
int offset[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
struct node{ int x,y,step;};//起点到(x,y)，已经走了step步骤 

int jianzhi(node e,int i)
{	int x1,y1;
	x1 = e.x+offset[i][0];
	y1 = e.y+offset[i][1];	
	if(x1<0 || x1>8 || y1<0 || y1>8) return 0;
	if(m[x1][y1] || mg[x1][y1])      return 0;//(x1,y1)为已跳过、障碍物，m[][]，mg[][]
	return 1;
}

int main()
{   
    int i;
    node e,e1;
	cin>>n;
	queue<node>Q;	
	while(n--)
	{
		cin>>a>>b>>c>>d;
		e.x = a; e.y = b; e.step = 0; //根节点
		m[a][b]=1;
		Q.push(e); 
		memset(m,0,sizeof(m));
		while(!Q.empty())
		{	
		   e=Q.front();
		   Q.pop();
		   if(e.x==c && e.y==d) break;
		   for(i=0;i<4;i++)	
		      if(jianzhi(e,i)) 
			  {
			  	e1.x = e.x + offset[i][0];
			  	e1.y = e.y + offset[i][1];
			  	e1.step = e.step +1;
				m[e1.x][e1.y]=1;
			  	Q.push(e1);
			  }
		}
		if(e.x ==c && e.y ==d) cout<<e.step<<endl ;
		else  cout<<"无法到达"<<endl;
		while(!Q.empty())	Q.pop();
	}
	return 0;
}

A*算法（优先队列式分枝限界法，简称优先队列式广搜）


#include<iostream>
#include<memory.h>
#include<queue>
#include<algorithm>
using namespace std;
int mg[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}
};
int n,a,b,c,d,m[9][9];
int offset[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
struct node{ 
	int x,y,step,len;
	bool operator < (const node &a) const
	{
		return step+len > a.step+a.len; //小的优先排队头
	}
};
//起点(a,b)到(x,y)，已经走了step步骤,到(c,d)至少还要走len步

int jianzhi(node e,int i)
{	int x1,y1;
	x1 = e.x+offset[i][0];
	y1 = e.y+offset[i][1];	
	if(x1<0 || x1>8 || y1<0 || y1>8) return 0;
	if(m[x1][y1] || mg[x1][y1])      return 0;//(x1,y1)为已跳过、障碍物，m[][]，mg[][]
	return 1;
}

int main()
{   
    int i;
    node e,e1;
	cin>>n;
	priority_queue<node>Q;	
	while(n--)
	{
		cin>>a>>b>>c>>d;
		e.x = a; e.y = b; e.step = 0; e.len = abs(a-c)+abs(b-d);//根节点
		m[a][b]=1;//(a,b)点已经进入队列 
		Q.push(e); 
		memset(m,0,sizeof(m));
		while(!Q.empty())
		{	
		   e=Q.top();
		   Q.pop();
		   if(e.x==c && e.y==d) break;
		   for(i=0;i<4;i++)	
		      if(jianzhi(e,i)) 
			  {
			  	e1.x = e.x + offset[i][0];
			  	e1.y = e.y + offset[i][1];
			  	e1.step = e.step +1;
				e1.len  = abs(e1.x-c)+abs(e1.y-d);//评估代价
				m[e1.x][e1.y]=1;//已经进入队列标志
			  	Q.push(e1);
			  }
		}
		if(e.x ==c && e.y ==d) cout<<e.step<<endl ;
		else  cout<<"无法到达"<<endl;
		while(!Q.empty())	Q.pop();
	}
	return 0;
}

输出路径


#include<iostream>
#include<memory.h>
#include<queue>
#include<algorithm>
#include<cstdio>
using namespace std;
int mg[20][20]=
{
 {0,1,0,0,0,1,1,1,0,1,0,1},
 {0,0,0,1,0,0,0,0,1,0,0,1},
 {0,1,0,1,0,1,1,1,0,1,0,0},
 {0,1,0,0,0,0,0,1,0,0,1,1},
 {0,0,0,0,1,0,0,0,0,0,0,0},
 {0,0,1,0,0,0,1,0,0,0,1,0},
 {0,0,1,0,0,0,0,0,1,0,0,0},
 {1,0,0,1,0,1,0,0,0,1,0,1},
 {0,0,1,0,1,0,1,0,1,0,0,0},
 {0,0,0,0,0,1,0,0,0,1,1,0},
 {0,0,0,0,0,1,0,0,0,0,0,0},
 {0,1,0,1,0,0,0,1,0,1,0,0}
};//迷宫12行12列 
int n=12,a,b,c,d,m[20][20];//n是迷宫行列数，m[][]辅助判断是否已经进入队列 
int offset[4][2]={{1,0},{-1,0},{0,1},{0,-1}};

struct node{ 
	int x,y,step,len;	
	struct node *parent; 
};//起点(a,b)到当前点(x,y)，已经走了step步,到(c,d)至少还要走len步

struct cmp
{
	bool operator () (const node *a,const node *b)
	{
		return a->step+a->len > b->step+b->len; //小的优先排队头
	}
};

void outputpath(node *e)
{
	int path[20][20]={0},i,j;
	for(i=0;i<n;i++)//拷贝迷宫数组到path[][]
	  for(j=0;j<n;j++) path[i][j] = mg[i][j];
	//从e到根，将对应步数写入path[][]
	while(e)
	{
		path[e->x][e->y] = e->step+1; //根结点step值为0，所以全部按+1处理 
		e = e->parent ;
	}
	for(i=0;i<n;i++)//输出path[][]
	{
	    for(j=0;j<n;j++) 
	       printf("%3d",path[i][j]);
	    printf("\n");
	}
}

node* jianzhi(node *e,int i)
{
	node *e1;
	int x1,y1;
	x1 = e->x+offset[i][0];
	y1 = e->y+offset[i][1];	
	if(x1<0 || x1>=n || y1<0 || y1>=n) return 0;
	if(m[x1][y1] || mg[x1][y1]) return 0;//(x1,y1)为已跳过、障碍物，m[][]，mg[][]
	e1 = new node;
	e1->x = e->x + offset[i][0];
	e1->y = e->y + offset[i][1];
	e1->step = e->step +1;
	e1->len  = abs(e1->x-c)+abs(e1->y-d);//评估代价
	e1->parent = e;
	return e1;
}

int main()
{   
    int i;
    node *e,*e1;	
	priority_queue<node*,vector<node*>,cmp>Q;	
    cin>>a>>b>>c>>d;
    e = new node; //创建根节点 
	e->x = a; e->y = b; 
	e->step = 0; 
	e->len = abs(a-c)+abs(b-d);//根节点到目标的评估距离
	e->parent = NULL; 	 
	Q.push(e); 
	memset(m,0,sizeof(m));
	m[a][b]=1;//(a,b)点已经进入队列
	while(!Q.empty())
	{	
		   e=Q.top();
		   Q.pop();
		   if(e->x==c && e->y==d) break;
		   for(i=0;i<4;i++)	
		      if(e1=jianzhi(e,i)) 
			  {			  	
				m[e1->x][e1->y]=1;//已经进入队列标志
			  	Q.push(e1);
			  }
	}
	if(e->x ==c && e->y ==d) 
	{
	    cout<<e->step<<endl;
	    outputpath(e);//沿着e结点往上访问祖先结点，从而确定路线并输出。 
	}
	else  cout<<"无法到达"<<endl;
	while(!Q.empty())	Q.pop();
	
	return 0;
}
qq_48566899
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
分治回溯算法----迷宫问题
NancyLCL的博客
01-21 440
迷宫问题：如图所示，在一个迷宫中从入口到出口前进按照方向的先后顺序寻找到一条出路。该图中灰色的格子表示是迷宫中的墙，白色的格子表示迷宫中的路。 //分治回溯算法解决解决迷宫出路问题 public class Maze { //以一个二维数组表示迷宫 1表示是墙走不通 0表示是路可以走通 private static int[][] maze = { {1, 1, 1, 1, 1, 1, 1, 1, 1}, {0, 0, 1, 0, 0,
分支限界法与回溯法
坤的专栏
06-08 2066
（1）求解目标：回溯法的求解目标是找出解空间树中满足约束条件的所有解，而分支限界法的求解目标则是找出满足约束条件的一个解，或是在满足约束条件的解中找出在某种意义下的最优解。 （2）搜索方式的不同：回溯法以深度优先的方式搜索解空间树，而分支限界法则以广度优先或以最小耗费优先的方式搜索解空间树。 分支限界法常以广度优先或以最小耗费（最大效益）优先的方式搜索问题的解空间树。 在分支限界法中，每一个
回溯法解决迷宫问题
龙跃十二
02-08 2080
今天在又一次看到了回溯法解决关于迷宫的问题，于是在这里分享给大家。 回溯法：对一个包括有很多个结点，每个结点有若干个搜索分支的问题，把原问题分解为若干个子问题求解的算法；当搜索到某个结点发现无法再继续搜索下去时，就让搜索过程回溯(回退)到该节点的前一个结点，继续搜索该节点外的其他尚未搜索的分支；如果发现该结点无法再搜索下去，就让搜索过程回溯到这个结点的前一结点继续这样的搜索过程；这样的搜索过程一...
分枝限界法
lyp
12-01 283
1.队列式分支限界法，普通BFS求解图的单源最短路问题 #include<stdio.h> #include<string.h> #include<queue> #include<vector> using namespace std; #define INF 0x3f3f3f3f #define MAXN 51 int n; int a[MAXN][MAXN]; int v; int dist[MAXN]; int prev[MAXN]; struct
栈-回溯法-迷宫求解代码实现
06-19
栈-回溯法-迷宫求解代码实现
PHP实现基于回溯法求解迷宫问题的方法详解
10-19
主要介绍了PHP实现基于回溯法求解迷宫问题的方法,结合实例形式详细分析了回溯法的原理、实现步骤与解决迷宫问题的相关操作技巧,需要的朋友可以参考下
回溯法求解迷宫
11-06
本程序 使用回溯法求解迷宫。 c# 语言wpf 开发，VS2010
回溯法解决数独问题-2.docx
01-27
"回溯法解决数独问题" 本文主要介绍了使用 MATLAB 解数独问题的回溯法解决方法。数独是一种非常流行的智力游戏，需要填充 9x9 的方格，使每一行、每一列、以及所分出的 9 个主要 3x3 区块，包含 1 到 9 所有的数字...
回溯算法的经典应用--迷宫寻径
烟雨朦胧的博客
03-03 532
#回溯算法的经典应用–迷宫寻径 先科普下啥是回溯算法，简单的说就是把一件事的所有可能性都测试一遍，对于初步可行的可能性在进行深度试探，初步就不行的就回到上一层可行的继续试探其他的可行性，直到寻求到所找目的。 最经典的应用，迷宫寻找出口，本例使用递归实现，话就不多说了，上代码。 #include &amp;lt;stdio.h&amp;gt; //路径图 用 1 模拟围墙，0为可通过的路径 int map[10]...
分支限界法-电子老鼠闯迷宫 java
05-28
有一只电子老鼠被困在如下图所示的迷宫中。这是一个12*12单元的正方形迷宫，黑色部分表示建筑物，白色部分是路。电子老鼠可以在路上向上、下、左、右行走，每一步走一个格子。现给定一个起点S和一个终点T，求出电子老鼠最少要几步从起点走到终点。
算法用回溯法解决迷宫问题
06-23
对于给定迷宫（n*n），和一个起始坐标和终点坐标，设计一个回溯算法，编程判断起点能否到达终点，若能打印出路径。 输入数据： 有文件input。txt给出数据。第一行有1个正整数n（表示迷宫大小），第二行为路径；‘x’表示墙。 结果输出： 若能打印路径，否则打印nopath！ 输入文件示例： 输入： 4 00 33 。。。。 。。。。 x x x 。 。。。。 输出： 0 。。。 0 0 0 0 x x x 0 。。。x
7-5 最近距离 (25 分)
reganmianbansuan的博客
11-21 1329
7-5 最近距离 (25 分) 在一个游戏中，玩家处于一个如下所示12行12列的迷宫： 0,1,0,0,0,1,1,1,0,1,0,1 0,0,0,1,0,0,0,0,1,0,0,1 0,1,0,1,0,1,1,1,0,1,0,0 0,1,0,0,0,0,0,1,0,0,1,1 0,0,0,0,1,0,0,0,0,0,0,0 0,0,1,0,0,0,1,0,0,0,1,0 0,0,1,0,0,0,...
分枝定界法
jahup的博客
01-25 1265
1.分支界定法(可求纯或混合整数线性规划): 2.割平面法(可求纯或混合整数线性规划): 3.隐枚举法(求"0-1"整数规划): 4.匈牙利法—解决指派问题（“0-1”规划特殊情形）: 5.蒙特卡洛法(求解各种类型的规划) ...
算法系列（四）：回溯法、分支限界法
qq_36763691的博客
11-19 4968
回溯法算法介绍策略算法流程 算法介绍 策略 我认为回溯法的策略可以当做蛮力法策略的延伸。当使用蛮力法解决问题时，我们会遍历所有可能的解，并且这种遍历的起始点是一样的。以走迷宫为例，如果我们使用蛮力法，将面临走不通就要完全从头走的情况。但是玩过迷宫游戏的人可能明白，在“试错”的过程中没有必要完全从头走，而是无路可走时，就返回上一步去做不同的选择，直观上就可以明白这更节约时间。 回溯法的基本策略就是这种更聪明的试错，即用“返回上一步”代替“完全从头走”。 算法流程 ...
分支回溯——迷宫问题
m0_49201977的博客
02-12 292
现有一个9*9的迷宫格子，我们需要从Enter找到Exit，将其存入一个9*9的二维数组内，0代表可以通过的路，1代表墙（不可通行） 同时我们在创建一个9*9的二位布尔数组，进行后续返回用 进入迷宫(1,0)开始循环方向看是否有墙（循环顺序为上、右、下、左），若能通过则在布尔数组内返回为true 循环遍历可行后入栈，如果走到 (1,3)上、下‘、左都遍历完后且无法通行，返回至(1,4)，且(1,4)之前通过（布尔数组内为true），则弹栈且返回false表示此路已经走过。 不断xun ...
数据挖掘-KNN-K最近邻算法
mike_jun的博客
07-03 1436
1.算法核心思想： 通过计算每个训练样本到待分类样本的距离，选取和待分类样本的距离最近的 K 个训练样本，K个样本中那个类别的训练样本占据着多数， 则表明待分类的样本就属于哪一个类别。 KNN算法在类别的决策中， 只与极少数的相邻样本相关。因此，对于类别的样本交叉或重叠较多的待分类样本集来说， KNN较其他算法较为适合。KNN算法的结果很大程度取决于K的选择。 ...
回溯法、分枝限定法--求解N个杯子分酒问题
qq_48566899的博客
12-07 320
n（<20）个没有刻度、容量分别为A1~ An的酒杯，初始装酒量分别为s1~ sn，求用最少次数倒成D1~ Dn的倒酒过程，其中A1~ An, s1~ sn, D1~Dn数据可以固定在程序中。 回溯法 1>解向量的分析 要求最少次数的倒酒过程，也就是说要求出第一步如何倒酒，第二步又如何倒酒，… 显然，每一步倒酒就是要记住从哪个杯子倒往哪个杯子，即2个杯子编号，所以可以用一个结构体数组struct { int from, to;} X[MAX]; 作为解向量。 2>解空间树与..
POJ3984—迷宫问题（bfs+ 打印路径）
ItaLink
05-08 198
定义一个二维数组： 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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。 ...
穷举法，回溯法和动态规划求解0-1
最新发布
06-12
穷举法、回溯法和动态规划是三种常用的算法策略，它们在解决优化问题特别是组合优化问题时十分有效。在0-1背包问题中，这三种方法可以用于求解物品分配方案。 1. **穷举法（Backtracking）**：这是一种试错的方法，通过递归地枚举所有可能的物品选择，从最小到最大逐一尝试，直到找到符合容量限制且价值最大的物品组合。这种方法会生成所有可能的解，但时间复杂度较高，对于大规模问题效率低下。 2. **回溯法（Backtracking）**：本质上也是穷举的一种变种，但它使用一种剪枝策略，避免了无效的搜索路径。当发现当前路径无法满足约束条件时，它会立即回溯到之前的决策点，尝试其他选择，直到找到解决方案或确定无解。这种方法适合于0-1背包问题，因为它能够控制搜索空间。 3. **动态规划（Dynamic Programming, DP）**：动态规划通常用于求解具有重叠子问题和最优子结构的问题。对于0-1背包问题，可以使用二维数组来记录每个容量下物品的最大价值，通过比较不包含某物品和包含某物品时的最优值来更新状态。这种方法避免了重复计算，效率更高，时间复杂度为O(nW)，其中n为物品数量，W为背包容量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值