POJ3984

又一道广搜的简单题目

定义一个二维数组： 

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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

输入

一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。

输出

左上角到右下角的最短路径，格式如样例所示

Sample Input

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

Sample Output

(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

思路：此题也可以套用广度搜索的模版，为啥不是DFS，因为是在求最短路的问题。逐层去扩展即可，不同点在于要记录遍历时的父节点的信息。

每次从队列拿出一个元素，扩展其相邻的4个元素入队列(要判重），直到队头元素为终点为止。队列里的元素记录了指向父节点（上一步）的指针。

队列不能用STL的queue或deque，要自己写，用一个双指针的数组实现队列。因为如果用queue的话，之前父亲节点的信息会丢失，这样无法通过指针返回父亲节点的信息。

坑的地方：

1，用数组表示搜索方向。上下左右 dx={-1,1,0,0} dy={0,0,1,-1}

2，尾指针++表示入队，头指针++表示出队

3，一定要标识是否访问过，此题可把障碍物和标识设为一组。

code：

#include<iostream>
#include<stack>
#include<stdlib.h>
#include<cstring>
using namespace std;
struct node{
	int r,c;
	int pre;
}queue[101];
int dx[]={1,-1,0,0};
int dy[]={0,0,1,-1};
int visited[5][5];
void printPath(int tail){
	stack<node> s;
	while(tail!=-1){
		s.push(queue[tail]);
		tail = 	queue[tail].pre;
	}
	while(!s.empty()){
		node n = s.top();
		cout<<"(" <<n.r<<", "<<n.c<<")" <<endl;
		s.pop();
	}	
}
//µÝ¹é´òÓ¡ 
void print(int i){
	if(q[i].pre!=-1){
		print(q[i].pre);
		cout<<"("<<q[i].x<<","<<" "<<q[i].y<<")"<<endl; //»ØËÝʱ´òÓ¡½á¹û 
	}
}
void bfs(int r,int c){
	int head=0;
	int tail=0;
	queue[head].r=r; 
	queue[head].c=c; 
	queue[head].pre=-1;
	tail++;
	while(head<tail){
		node temp = queue[head];
		int cur_c,cur_r;
		for(int i=0;i<4;i++){
			cur_r=temp.r+dx[i];
			cur_c=temp.c+dy[i];
			if(visited[cur_r][cur_c] || cur_c<0||cur_c>4||cur_r<0||cur_r>4)
			    continue;
			else{
				visited[cur_r][cur_c]=1;
				queue[tail].c=cur_c;
				queue[tail].r=cur_r;
				queue[tail].pre=head;				
			}
			if(cur_c==4&&cur_r==4)
			{
				printPath(tail);
			}
			tail++;	
		}
		head++;	
	}
} 

int main(){
	//freopen("test.in","r",stdin);
	memset(visited,0,sizeof(visited));
	for(int i=0;i<5;++i){
		for(int j=0;j<5;j++){
			cin>>visited[i][j];
		}
	}
	bfs(0,0);
	return 0;
}