BFS:NEEPUOJ3006推箱子

标签: BFS NEEPUOJ 最短路
4人阅读 评论(0) 收藏 举报

有大神说可以单次BFS完成,一直也没有搞明白,这里给出的是双层BFS解法。阅读题目发现输入数据量并不大,地图最大长度7,但是搜索过程中要考虑的情况却是较为复杂的。

首先需要把箱子从初始位置移动到目标位置,采用BFS计算路径最短路在这里显然很适合。当然到这里没什么难度,但题里是需要让搬运工来推箱子的,所以这道题在每次箱子进行位移的时候需要对搬运工进行判断,判断他是否能够移动到对应推箱子的位置(如果箱子想要左移,那么搬运工必须能够到达箱子的右边)。判断失败箱子的这次尝试的移动就会跳过,判断成功则移动箱子,并将搬运工的坐标移至箱子的原坐标下。

搬运工的判断我也采用的BFS搜索,对当前地图情况进行搜索,仅采用一个额外的标记矩阵记录下搬运工BFS已走过的路径,到达目标地立即停止返回判断成功,全部可走路径都判断完毕则返回失败。

就这样程序由两层BFS组成,第一层BFS来搜索箱子是否能移动目标地,每次箱子的尝试移动都需要第二层BFS搜索判断搬运工是否能移动到指定位置。需要注意的是第一层BFS需要记录箱子的坐标、搬运工的坐标以及已走的步数。缺一不可。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
int BFS(int* array);
int checkBFS(int endx,int endy,int beginx,int beginy);
struct node
{
    int boxx;
	int boxy;
	int manx;
	int many;
	int num;
};
struct nodes
{
	int x;
	int y;
};
int matrix[7][7];
int m,n;
int main(int argc,char* argv[])
{
	int num;
	scanf("%d",&num);
	while(num--)
	{
		scanf("%d%d",&m,&n);
		int array[6];
		int i,j;
		memset(matrix,0,sizeof(matrix));
		for(i=0;i<m;i++)
			for(j=0;j<n;j++)
			{
				scanf("%d",&matrix[i][j]);
				if(matrix[i][j]==2)
				{
					array[0]=i;
					array[1]=j;
				}
				if(matrix[i][j]==3)
				{
					array[2]=i;
					array[3]=j;
				}
				if(matrix[i][j]==4)
				{
					array[4]=i;
					array[5]=j;
				}
			}
		int now=BFS(array);
		printf("%d\n",now);
	}
	return EXIT_SUCCESS;
}
int BFS(int* array)
{
	struct node que[60];
	int book[7][7];
	int move[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
    memset(book,0,sizeof(book));
    int head=1;
    int body=1;
    que[body].boxx=array[0];
    que[body].boxy=array[1];
    que[body].manx=array[4];
    que[body].many=array[5];
    que[body].num=0;
    body++;
    book[array[0]][array[1]]=1;
    while(head<body)
    {
    	int i;
        for(i=0;i<4;i++)
        {
        	int tx,ty;
            tx=que[head].boxx+move[i][0];
            ty=que[head].boxy+move[i][1];
            if(tx<0||ty<0||tx>=m||ty>=n)
				continue;
			if(!book[tx][ty]&&matrix[tx][ty]!=1)
			{
				int control;
				if(i==0)
				{
					matrix[que[head].boxx][que[head].boxy]=1;
					control=checkBFS(tx-2,ty,que[head].manx,que[head].many);
					matrix[que[head].boxx][que[head].boxy]=0;
				}
				if(i==1)
				{
					matrix[que[head].boxx][que[head].boxy]=1;
					control=checkBFS(tx+2,ty,que[head].manx,que[head].many);
					matrix[que[head].boxx][que[head].boxy]=0;
				}
				if(i==2)
				{
					matrix[que[head].boxx][que[head].boxy]=1;
					control=checkBFS(tx,ty-2,que[head].manx,que[head].many);
					matrix[que[head].boxx][que[head].boxy]=0;
				}
				if(i==3)
				{
					matrix[que[head].boxx][que[head].boxy]=1;
					control=checkBFS(tx,ty+2,que[head].manx,que[head].many);
					matrix[que[head].boxx][que[head].boxy]=0;
				}
				//printf("BFS>>control=%d,tx=%d,ty=%d\n",control,tx,ty);
				if(control)
				{
					book[tx][ty]=1;
                	que[body].boxx=tx;
                	que[body].boxy=ty;
                	que[body].manx=que[head].boxx;
                	que[body].many=que[head].boxy;
                	que[body].num=que[head].num+1;
                	body++;
				}
			}
            if(que[body-1].boxx==array[2]&&que[body-1].boxy==array[3])
            	return que[body-1].num;
        }
        head++;
    }
    return -1;
}
int checkBFS(int endx,int endy,int beginx,int beginy)
{
	//printf("checkBFS>>beginx=%d,beginy=%d,endx=%d,endy=%d\n",beginx,beginy,endx,endy);
	struct nodes ques[60];
	int books[7][7];
	int move[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
    memset(books,0,sizeof(books));
    int head=1;
    int body=1;
    ques[body].x=beginx;
    ques[body].y=beginy;
    body++;
    while(body>head)
    {
    	int i;
    	for(i=0;i<4;i++)
    	{
    		int tx,ty;
        	tx=ques[head].x+move[i][0];
        	ty=ques[head].y+move[i][1];
        	if(tx<0||ty<0||tx>=m||ty>=n)
				continue;
			if(!books[tx][ty]&&matrix[tx][ty]!=1)
            {
                books[tx][ty]=1;
                ques[body].x=tx;
                ques[body].y=ty;
                body++;
            }
			if(ques[body-1].x==endx&&ques[body-1].y==endy)
				return 1;
    	}
		head++;
    }
    return 0;
}


查看评论

推箱子游戏开发

1.本项目需要掌握java基本知识,类的定义,封装,继承及多态;异常处理机制;Swing界面编程,Swing控件的使用,JAVA的事件处理机制,Java绘画图片;IO流读取文件操作等; 2.综合利用JAVA知识实现推箱子游戏的开发; 3.主要功能为实现推箱子游戏的界面;实现推箱子游戏算法;实现悔一步功能;实现播放背景音乐等功能。
  • 2016年07月04日 16:11

笔试题--推箱子问题(BFS算法)

大家一定玩过“推箱子”这个经典的游戏。具体规则就是在一个N*M的地图上,有1个玩家、1个箱子、1个目的地以及若干障碍,其余是空地。玩家可以往上下左右4个方向移动,但是不能移动出地图或者移动到障碍里去。...
  • u010221508
  • u010221508
  • 2017-04-23 15:37:28
  • 2093

hdu 1254 推箱子/poj 1475 Pushing Boxes(推箱子经典问题,BFS嵌套BFS)

推箱子 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Subm...
  • acm_cxq
  • acm_cxq
  • 2016-08-04 22:12:35
  • 878

推箱子(双重bfs)

题目意思:不用多说,就是小时候古董手机上的小游戏推箱子(好像暴露了年龄hh)。 解题思路:其实刚开始我在想BFS,但是没有考虑到对人的搜寻。最后参考了别人的思路才知道用双重bfs(hh小学渣) 对...
  • Seawindson
  • Seawindson
  • 2016-07-14 12:14:02
  • 478

hdu 1254 推箱子(bfs判断路径可达+bfs搜索最小)

推箱子 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Subm...
  • qq_24451605
  • qq_24451605
  • 2015-04-25 12:27:25
  • 1089

hdu1254 推箱子(bfs+bfs)

推箱子 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) Total Submiss...
  • d_x_d
  • d_x_d
  • 2015-10-23 18:54:46
  • 1833

POJ 1111(数字很吉利嘛) 简单BFS

POJ 1111 easy BFS Image Perimeters Time Limit: 1000MS Memory Limit: 10000K Total Submissio...
  • qq_31785871
  • qq_31785871
  • 2016-03-20 11:13:31
  • 624

hdu 1254 推箱子 BFS

hdu 1254 推箱子 BFS[含测试数据] 题目链接: Here! 思路:每次箱子移动之前,肯定都是人先到达箱子相邻的位置上,然后推动箱子移动一步。比如:箱子现在的位置是(x,y),如果箱子需要向...
  • ACMore_Xiong
  • ACMore_Xiong
  • 2016-07-12 20:09:19
  • 939

推箱子的AI算法

这一次让偶仍然用拿手的穷举法来写一个自动解推箱子问题的机器人吧。偶使用了yzwykkldczsh同志写的状态机模板以及该模板的配套算法“万用智能超级无穷迭代动态规划递归算法”(为纪念友人Jornath...
  • superarhow
  • superarhow
  • 2006-06-29 14:19:00
  • 4366

一个箱子的推箱子算法

题目意思:很简单,推箱子。给出步骤最少的一种方案即可 解题思路:本题宜采用优先队列,使得步骤越少其优先级越高。关键在于处理son数组的问题。...
  • hqf1992
  • hqf1992
  • 2015-07-28 10:04:25
  • 2073
    个人资料
    等级:
    访问量: 46
    积分: 54
    排名: 168万+
    文章分类
    文章存档