PTA求解迷宫从入口到出口的路径(广搜,C语言）

求解迷宫从入口到出口的路径。输入一个迷宫，求从入口通向出口的可行路径。为简化问题，迷宫用二维数组 int maze[10][10]来存储障碍物的分布，假设迷宫的横向和纵向尺寸的大小是一样的，并由程序运行读入, 若读入迷宫大小的值是n（3<n<=10），则该迷宫横向或纵向尺寸都是n，规定迷宫最外面的一圈是障碍物，迷宫的入口是maze[1][1]，出口是maze[n-2][n-2], 若maze[i][j] = 1代表该位置是障碍物，若maze[i][j] = 0代表该位置是可以行走的空位（0<=i<=n-1, 0<=j<=n-1）。求从入口maze[1][1]到出口maze[n-2][n-2]可以走通的路径。要求迷宫中只允许在水平或上下四个方向的空位上行走，走过的位置不能重复走，规定必须按向右、向下、向左、向上的顺序向前搜索试探。
如下这样一个迷宫：
​
对应的二维数组表示：
int maze[10][10]={
{1,1,1,1,1,1,1,1,1,1},
{1,0,0,1,0,0,0,1,0,1},
{1,0,0,1,0,0,0,1,0,1},
{1,0,0,0,0,1,1,0,0,1},
{1,0,1,1,1,0,0,0,1,1},
{1,0,0,0,1,0,0,0,1,1},
{1,0,1,0,0,0,1,0,0,1},
{1,1,1,1,0,1,1,0,1,1},
{1,0,0,0,0,0,0,0,0,1},
{1,1,1,1,1,1,1,1,1,1}};

输入格式:
输入迷宫大小的整数n, 以及n行和n列的二维数组（数组元素1代表障碍物，0代表空位）。

输出格式:
依次输出从入口到出口可行路径每个位置的行列下标（i,j），每个位置间用“,”分隔。若没有通路，输出：NO。

输入样例1:

4
1 1 1 1
1 0 1 1
1 0 0 1
1 1 1 1

输出样例1:

(1,1)(2,1)(2,2)

输入样例2:

10
1 1 1 1 1 1 1 1 1 1
1 0 0 1 0 0 0 1 0 1
1 0 0 1 0 0 0 1 0 1
1 0 0 0 0 1 1 0 0 1
1 0 1 1 1 0 0 0 0 1
1 0 0 0 1 0 0 0 0 1
1 0 1 0 0 0 1 0 0 1
1 0 1 1 1 0 1 1 0 1
1 1 0 0 0 0 0 0 0 1
1 1 1 1 1 1 1 1 1 1

输出样例2:

(1,1)(1,2)(2,2)(3,2)(3,1)(4,1)(5,1)(5,2)(5,3)(6,3)(6,4)(6,5)(7,5)(8,5)(8,6)(8,7)(8,8)

基本思路:
调用递归函数，对当前所在位置的上下左右进行探索，当标志值不为1(墙或者已探索)，前进到空地，接着探索当前位置。若遇到死胡同(四面均为1)，则不断退出调用的递归函数，回到决策点，接着探索决策点的其他方向。
若在探索过程中，到达了目的地，则将flag设为1。递归结束时，若flag仍为0，则说明迷宫无解，打印(“NO\n”)
代码实现:

#include<bits/stdc++.h>
typedef struct {
	int status;//0为未探索，1为墙壁以及已探索，正在探索为2
	int comefrom;//由上到下为1，下到上为-1，左到右2，右到左为-2
} maze;
maze A[1000][1000];
int n,flag=0;
void print(int a, int b) {
	if (A[a][b].comefrom == 1) {
		print(a - 1, b);
		printf("(%d,%d)", a, b);
	}
	if (A[a][b].comefrom == -1) {
		print(a + 1, b);
		printf("(%d,%d)", a, b);
	}
	if (A[a][b].comefrom == 2) {
		print(a, b - 1);
		printf("(%d,%d)", a, b);
	}
	if (A[a][b].comefrom == -2) {
		print(a, b + 1);
		printf("(%d,%d)", a, b);
	}
	if (a == 1 && b == 1)
		printf("(%d,%d)", a, b);
}
void explore( int i, int j) {
	if (A[i][j + 1].status == 0) {//向右
		A[i][j + 1].status = 1;
		A[i][j + 1].comefrom = 2;
		explore(i, j + 1);
	}
	if (A[i + 1][j].status == 0) {//向下
		A[i + 1][j].status = 1;
		A[i + 1][j].comefrom = 1;
		explore(i + 1, j);
	}
	if (A[i][j - 1].status == 0) {//向左
		A[i][j - 1].status = 1;
		A[i][j - 1].comefrom = -2;
		explore(i, j - 1);
	}
	if (A[i - 1][j].status == 0) {//向上
		A[i - 1][j].status = 1;
		A[i - 1][j].comefrom = -1;
		explore(i - 1, j);
	}
		if (i == n - 2 && j == n - 2) {
			print(i, j);
			flag=1;
		}
	if (A[i][j + 1].status == 1 && A[i + 1][j].status == 1 && A[i][j - 1].status == 1 && A[i - 1][j].status == 1)
		return ;

}

int main() {
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++)
			scanf("%d", &A[i][j].status);
	}
	A[1][1].status = 1;
	explore(1, 1);
	if(flag==0)
	printf("NO\n");
}

缺点：当前算法需要遍历整张地图。有些路线的成功概率高，应该优先探索，可节省时间。推荐A*算法