编程训练——输出迷宫所有解（不是迷宫最短路）

题目描述

之前写过一个用BFS解决迷宫最短路的问题，这篇文章则是另外一个问题，那就是输出迷宫的所有可能路径。直接看样例输入输出就明白题意了：

样例输入1

3
s..
*.*
..e

3代表迷宫是3 $\times$ 3的，s代表起点，e代表终点，.代表路，'*'代表墙壁。

样例输出1

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

显然这个迷宫只有一条路径，上述输出了从起点的下一步开始的所有点坐标。

样例输入2

3
s..
*..
..e

样例输出2

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

这个迷宫问题有4个解。

数据规定

规定输入位置坐标一定是(0,0)，迷宫是正方形，且最大规模不超过100 $\times$ 100.
（想让迷宫是长方形也可以，给下面的程序加一个长度或者宽度的变量就行了）

算法

核心算法用伪代码表示：

// 从当前点(x,y)开始寻找终点
findPath(int x, int y){
	置(x,y)访问标记;
	if (x,y) 是终点{
		输出路径数组中所有点;
		输出回车;
	}
	else{
		for 每一个(x,y)的邻居A{
			若能到A，则将A加入路径数组;
			findPath(A的坐标);	// 递归调用
			将A从路径数组清除;
		}
	}
	取消(x,y)访问标记;
}

所用数据结构及辅助功能的构造不赘述，详见参考代码。

参考代码

#include<stdio.h>

#define maxn 105

int flag[maxn][maxn];   // 访问标记
char map[maxn][maxn];   // 地图
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};

// 存储路径的坐标，如果用c++，可以用pair代替
int path_x[maxn*maxn];  // 存储路径的横坐标
int path_y[maxn*maxn];  // 存储路径的纵坐标
int length; // 除了终点外的路径点数
int n;  // 地图的规模

void findPath(int x, int y){
    flag[x][y] = 1;
    if(map[x][y]=='e'){
        for(int i = 0;i < length;i++){
            printf("(%d,%d)", path_x[i], path_y[i]);
        }
        printf("\n");
    }
    else{
        for(int i = 0;i < 4;i++){
            if(x+dx[i]>=0&&x+dx[i]<n&&y+dy[i]>=0&&y+dy[i]<n
            &&flag[x+dx[i]][y+dy[i]]==0&&map[x+dx[i]][y+dy[i]]!='*'){
                path_x[length] = x + dx[i];
                path_y[length++] = y + dy[i];
                findPath(x+dx[i], y+dy[i]);
                length--;
            }
        }
    }
    flag[x][y] = 0;
}

int main(){
    while(scanf("%d", &n)==1){
        getchar();
        for(int i = 0;i < n;i++){
            for(int j = 0;j < n;j++){
                scanf("%c", &map[i][j]);
            }
            getchar();
        }

        findPath(0, 0);
    }

    return 0;
}

拓展（骑士游历问题）

拓展一道题：骑士游历问题，输入棋盘规模，输入骑士的初始坐标，骑士只能走“日”字形，求一个能不重复走完所有格子的路径。

也是使用迷宫问题的算法思想，但是这个算法用在骑士游历问题上，复杂度相当高，运行程序时肉眼可见的慢。网上还有结合贪心法的解法，那个应该是求解骑士游历问题的合理解法，这里我仅仅为迷宫问题作拓展巩固。

参考代码：

// 这个算法复杂度太高了，是指数级别的，运行速度肉眼可见的慢
// 网上还有一种方法是结合了贪心法的思想，如果以后有兴趣可以看（可以去参考https://blog.csdn.net/wqk1014/article/details/8283325?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task）

#include<stdio.h>

#define maxn 105

int flag[maxn][maxn];
int end = 0;    // 标记程序是否结束
int count = 0;  // 武士棋已走步数
int n;  // 棋盘规模
int path_x[maxn+1], path_y[maxn+1];
int start_x, start_y;   // 起点坐标
int dx[8] = {-2, -1, 1, 2, 2, 1, -1, -2};
int dy[8] = {1, 2, 2, 1, -1, -2, -2, -1};

void findPath(int x, int y){
    printf("发生一次调用，count=%d\n", count);
    flag[x][y] = 1;
    if(count == n * n){
        end = 1;    // 因为只用输出一组解，所以找到一个解后就标记程序结束
        for(int i = 0;i < count;i++){
            printf("(%d,%d)", path_x[i], path_y[i]);
        }
        printf("\n");
    }
    else{
        for(int i = 0; i < 8;i++){
            if(x+dx[i]>=0&&x+dx[i]<n&&y+dy[i]>=0&&y+dy[i]<n
                &&flag[x+dx[i]][y+dy[i]]==0){
                path_x[count] = x + dx[i];
                path_y[count++] = y + dy[i];
                if(end == 0){
                    findPath(x+dx[i], y+dy[i]);
                }
                count--;
            }
        }
    }
    flag[x][y] = 0;
}

int main(){
    while(scanf("%d", &n)==1){
        scanf("%d %d", &start_x, &start_y);
        count = 0;
        end = 0;
        path_x[count] = start_x;
        path_y[count++] = start_y;
        findPath(start_x, start_y);
    }

    return 0;
}