NYOJ 58 最少步数

最少步数

时间限制： 3000 ms  |  内存限制： 65535 KB

难度： 4

描述

这有一个迷宫，有0~8行和0~8列：

 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

0表示道路，1表示墙。

现在输入一个道路的坐标作为起点，再如输入一个道路的坐标作为终点，问最少走几步才能从起点到达终点？

（注：一步是指从一坐标点走到其上下左右相邻坐标点，如：从（3，1）到（4,1）。）

输入

第一行输入一个整数n（0<n<=100），表示有n组测试数据;
随后n行,每行有四个整数a,b,c,d（0<=a,b,c,d<=8）分别表示起点的行、列，终点的行、列。

输出

输出最少走几步。

样例输入

2
3 1  5 7
3 1  6 7

样例输出

12
11

解法一：

这道题使用DFS ，看似很简单，但是你需要明白它的递归过程，这是一个迷宫，直接用MG二维数组表示，
当进行第一样例测试时，MG[i][j]=1;会使所有为0的值变为1，使其全部为1，当然你不要忽略
MG[nx][ny]=0;，当某种情况遍历到出口，sum会记下最小步数，然后返回，这时就会使用MG[nx][ny]=0，
把刚才那条路径的值都返回原值0；当全部都遍历完时，也就找到了最小步数，MG中也都返回了原值0；
不过这个时候你要注意了，main函数中MG[x1][y1]=0;这一代码非常重要，他是返回开始节点的值为0；使MG
这个表完全变成开始的时候，然后进行下一个测试样例。 */


#include<cstdio> 
#include<algorithm>
#include<iostream>
using namespace std;
int x1,y1,x2,y2,sum;
int dx[4]={0,-1,0,1},dy[4]={-1,0,1,0};
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}
};
void dfs(int i,int j,int s)
{  
   if(i==x2&&j==y2){
      if(s<sum)sum=s;
	return;
	}
   MG[i][j]=1;
   for(int m=0;m<4;m++){
	int nx=i+dx[m];
	int ny=j+dy[m];
	if(!MG[nx][ny])
 	{	dfs(nx,ny,s+1);
		MG[nx][ny]=0;
    }
	}   
}
int main()
{
  int test;
  scanf("%d",&test);
  while(test--){
	scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
    sum=1000; 
    dfs(x1,y1,0);
    MG[x1][y1]=0;    //对于这个限定条件用的真绝 
    printf("%d\n",sum);
	}
	return 0;
}

解法二：

使用BFS进行求解，速度稍微慢了点，

使用队列，又用了pair成对容器记录坐标（x,y）

#include<cstdio>
#include<queue>
#include<algorithm>
#include<iostream>
#define INF 10000
using namespace std;
typedef pair<int,int> P;   //使用pair成对表示坐标（x,y） 
int x1,y1,x2,y2,d[9][9];   //记录最短路径 
int dx[4]={0,-1,0,1},dy[4]={-1,0,1,0};
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 Bfs(int i,int j)
{  
   queue<P> que;
   que.push(P(i,j));
   d[i][j]=0;
   while(que.size()){
	P a=que.front();que.pop();
	if((a.first==x2)&&(a.second==y2))break; //当第一次遍历到终点时，也就是最短的路径，因为他是BFs 
   	for(int m=0;m<4;m++){
		int nx=a.first+dx[m];
		int ny=a.second+dy[m];
		if(MG[nx][ny]!=1&&d[nx][ny]==INF){
			que.push(P(nx,ny));
			d[nx][ny]=d[a.first][a.second]+1;
			}
		}
	}
	return d[x2][y2];
}
int main()
{
  int test;
  scanf("%d",&test);
  while(test--){
	scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
	for(int m=0;m<9;m++)
	  for(int n=0;n<9;n++)d[m][n]=INF; 
   	int sum=Bfs(x1,y1);
    printf("%d\n",sum);
	}
	return 0;
}