华为OJ（迷宫问题）

描述

定义一个二维数组N*M（其中2<=N<=10;2<=M<=10），如5 × 5数组下所示：  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,0],既第一空格是可以走的路。 Input 一个N × M的二维数组，表示一个迷宫。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。 Output 左上角到右下角的最短路径，格式如样例所示。 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)

一个空格引发的一场郁闷风暴。。。。

这样写时cout<<'('<<temp.x-1<<', '<<temp.y-1<<')'<<endl; 输出是酱紫的。。。。注意逗号后面跟着一个空格

尝试好多次，终于发现逗号后的空格去掉后，输出是酱紫的：

哇塞！好神（wu）奇（yu）！为啥总有些人喜欢输出符号等字符串时用单引号单字符呢？

谁来给我扫扫盲。(╯□╰)o

说正题，使用BFS（广度优先搜索），参考别人的代码自己第二天重写了一遍，不过这里还是放大牛的代码吧，毕竟自己懒得注释(haha)：

/*
迷宫问题（八方向）
input:
1
6 8
0 1 1 1 0 1 1 1
1 0 1 0 1 0 1 0
0 1 0 0 1 1 1 1
0 1 1 1 0 0 1 1
1 0 0 1 1 0 0 0
0 1 1 0 0 1 1 0
output:
YES
(1,1) (2,2) (3,3) (3,4) (4,5) (4,6) (5,7) (6,8)
*/
#include<iostream>
#include<queue>
#include<stack>
using namespace std;
struct point{
    //横坐标纵坐标
    int x;
    int y;
};
int **Maze;     //初始化迷宫
point **Pre;    //保存任意点在路径中的前一步
point move_ori[4]={{-1,0},{0,-1},{0,1},{1,0}};      //移动方向，横竖斜都可以，八个方向
void Create(int row,int column){
    //创建迷宫，注意到用0表示可走，1表示墙，将整个输入的迷宫再用墙围着，处理的时候就不用特别注意边界问题
    int i,j;
    for(i=0; i<row+2; i++)
		Maze[i][0] = Maze[i][column+1] = 1;
    for(j=0; j<column+2; j++)
		Maze[0][j] = Maze[row+1][j] = 1;
    for(i=1; i<=row; i++){
        for(j=1; j<=column; j++){
            cin>>Maze[i][j];
        }
    }
}
bool MazePath(int row,int column,int x,int y){
    //判断是否有路径从入口到出口，保存该路径（队列）
    if(x == row && y == column)return true;
    queue<point> q;     //用于广度优先搜索
    point now;          //当前位置
    now.x = x;
    now.y = y;
    q.push(now);
    Maze[now.x][now.y] = -1;
    while(!q.empty()){
        now = q.front();
        q.pop();
        for(int i=0; i<4; i++)
		{
            if(now.x + move_ori[i].x == row && now.y + move_ori[i].y == column)
			{
                Maze[now.x + move_ori[i].x][now.y + move_ori[i].y] = -1;
                Pre[row][column] = now;
                return true;
            }
            if(Maze[now.x + move_ori[i].x][now.y + move_ori[i].y] == 0)
			{
                point temp;     //下个位置
                temp.x = now.x + move_ori[i].x;
                temp.y = now.y + move_ori[i].y;
                q.push(temp);
                Maze[temp.x][temp.y] = -1;
                Pre[temp.x][temp.y] = now;

            }
        }
    }
    return false;
}
void PrintPath(int row,int column){
    //输出最短路径
    point temp;         //保存位置
    stack<point> s;     //保存路径序列
    temp.x = row;
    temp.y = column;
    while(temp.x != 1 || temp.y != 1){
        s.push(temp);
        temp = Pre[temp.x][temp.y];
    }
    cout<<"(0,0)"<<endl;
    while(!s.empty())
	{
        temp = s.top();
        cout<<'('<<temp.x-1<<","<<temp.y-1<<')'<<endl;//
		s.pop();
    }
    cout<<endl;
}
int main(){
         //用例数量
    int row;        //迷宫行数
    int column;     //迷宫列数
   
   
        cin>>row>>column;
        Maze = new int*[row + 2];
        Pre = new point*[row + 2];
        for(int i=0; i<row+2; i++){
            Maze[i] = new int[column + 2];
            Pre[i] = new point[column + 2];
        }
        Create(row,column);
		if(MazePath(row,column,1,1))		   
		    PrintPath(row,column);
		
  
	//system("pause");
    return 0;
}