华为c语言迷宫最短路径算法,【华为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 Input0 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)

输入描述:

输入两个整数，分别表示二位数组的行数，列数。再输入相应的数组，其中的1表示墙壁，0表示可以走的路。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。

输出描述:

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

输入例子: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

输出例子:(0,0)

(1,0)

(2,0)

(2,1)

(2,2)

(2,3)

(2,4)

(3,4)

(4,4)

广度优先搜索代码#include

#include

#include

using namespace std;

struct point{

//横坐标和纵坐标

int x;

int y;

};

int **Maze; //初始化迷宫

point **Pre; //保存任意点在路径中的前一步

point move_ori[8] = { { -1, 0 }, { 0, -1 }, { 0, 1 }, { 1, 0 }, { -1, 1 }, { -1, -1 }, { 1, -1 }, {1,1} };

//移动方向，横竖斜都可以，八个方向

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;

queueq;//用于广度优先搜索

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 < 8; 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;

stacks;

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();

}

}

int main(){

int row;//迷宫行数

int column;//迷宫列数

while (~scanf_s("%d%d", &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);

}

return 0;

}

运用深度优先搜索和回溯法的有待后面在补充