回溯算法的常见例题之《迷宫》

回溯算法的常见例题之《迷宫》

回溯算法——百度百科：

回溯算法也叫试探法，它是一种系统地搜索问题的解的方法。

用回溯算法解决问题的一般步骤：

1 针对所给问题，定义问题的解空间，它至少包含问题的一个（最优）解。

2 确定易于搜索的解空间结构,使得能用回溯法方便地搜索整个解空间 。

3 以深度优先的方式搜索解空间，并且在搜索过程中用剪枝函数避免无效搜索。

问题的解空间通常是在搜索问题解的过程中动态产生的，这是回溯算法的一个重要特性。

以上是来自百度百科对于回溯算法的解释。

通俗的讲，回溯就是不断向前探索，一条阳关道走到黑，碰到死胡同就回来，追根溯源，追溯到刚刚走的岔路口，告诉自己这条路不能走了，把这条路拉黑，换一条。走下一条吧，然后以与刚刚同样节奏的步伐开心愉悦的走到下一个路口。

典型的回溯问题就是《迷宫》，如下图，有一个迷宫，小人儿每次只能走一格，每次有四个方向可以选择，以下右上左的顺序向前探索，如果四个方向都无法向前走的话，就回溯，即退回到刚刚那一步，转向下一个方向进行探索。这样描述下来的话代码就呼之欲出了，按照这样的思路，代码如下：

package Maze;
/*C语言编写：
设置成多一圈墙的原因是为了让最外面的格子也有四个方向可以遍历
* #include<stdio.h>
#include<stdlib.h>
#define m 12
#define n 16
int count;

//初始化一个迷宫数组并设置道路    0表示墙,1表示路
int maze[m]
;
//初始化一个偏移量数组
int move[4][2]= {{1,0},{0,1},{-1,0},{0,-1}};

//迷宫算法
int MAZE(int x, int y)
{
int a,b;
int tag= 0;
if(x==10 && y==14)
return 1;
for(int i= 0; i<4; i++)
{
a= x+ move[i][0];
b= y+ move[i][1];
if(maze[a][b]== 1)
{
maze[a][b]= 2;//如果可以走,就走(a,b),然后(a,b)上的值改成2表示走过的路
tag= MAZE(a, b);
if(tag){
count++;
printf("(%d,%d)←",a,b);
return 1;
}
}
}
return 0;
}
int main(void)
{
//步数
count= 0;
for(int i= 0; i<m; ++i){
for(int j= 0; j<n; ++j){
maze[i][j]= 0;
}
}
maze[1][1]  =maze[1][2] =maze[1][3] =maze[1][4] =maze[1][5] =1;
maze[2][1]  =maze[2][5] =maze[2][6] =1;
maze[3][1]  =maze[3][2] =maze[3][6] =maze[3][7] =maze[3][8] =maze[3][9] =maze[3][10]=1;
maze[4][2]  =maze[4][6] =maze[4][10]=maze[4][11]=1;
maze[5][2]  =maze[5][11]=maze[5][12]=1;
maze[6][2]  =maze[6][3] =maze[6][4] =maze[6][5] =maze[6][6] =maze[6][7] =maze[6][8] =maze[6][12]=1;
maze[7][3]  =maze[7][8] =maze[7][12]=maze[7][13]=1;
maze[8][3]  =maze[8][4] =maze[8][8] =maze[8][9] =maze[8][10]=maze[8][13]=1;
maze[9][10] =maze[9][11]=maze[9][12]=maze[9][13]=maze[9][14]=1;
maze[10][14]=1;
//调用MAZE
MAZE(1,1);
//迷宫入口
printf("(1,1)←入口");
printf("\n");
printf("总共走的步数是：%d步\n",count);
return 0;
}
* */
* /**Java编写，没有太大的区别*/
public class Maze {
public static final int m= 12;//行
public static final int n = 16; //列
public static  int count= 0;//计步数
public static int maze[][]= new int[12][16];    //迷宫数组
public static int move[][]= {{1,0},{0,1},{-1,0},{0,-1}};//方向数组
public static int x= 0,y= 0;//坐标变量
public static boolean tag= false;//结束标志位
/**迷宫算法
* @return boolean*/
public static boolean MAZE(int x , int y){
//入口是（1,1）；出口是（10,14）
if(x== 10 || y ==14)
return true;
int a,b;
boolean tag= false;
//遍历4个方向
for(int i= 0; i<4; i++)
{
a= x+ move[i][0];
b= y+ move[i][1];
if(maze[a][b]== 1)
{
maze[a][b]= 2;//如果可以走,就走(a,b),然后(a,b)上的值改成2表示走过的路
tag= MAZE(a, b);
if(tag){
count++;//计算走了几步
System.out.print(" （"+a+"，"+b+"）← ");
return tag;
}
}
}
//方向全部遍历完 说明没有能走的方向，就退一步，return 到上一个递归调用
return false;
}
public static void main(String[] args) {
//初始化步数
count= 0;
/**初始化迷宫的墙和路*/
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
maze[i][j]= -1;
}
}
maze[1][1]  =maze[1][2] =maze[1][3] =maze[1][4] =maze[1][5] =1;
maze[2][1]  =maze[2][5] =maze[2][6] =1;
maze[3][1]  =maze[3][2] =maze[3][6] =maze[3][7] =maze[3][8] =maze[3][9] =maze[3][10]=1;
maze[4][2]  =maze[4][6] =maze[4][10]=maze[4][11]=1;
maze[5][2]  =maze[5][11]=maze[5][12]=1;
maze[6][2]  =maze[6][3] =maze[6][4] =maze[6][5] =maze[6][6] =maze[6][7] =maze[6][8] =maze[6][12]=1;
maze[7][3]  =maze[7][8] =maze[7][12]=maze[7][13]=1;
maze[8][3]  =maze[8][4] =maze[8][8] =maze[8][9] =maze[8][10]=maze[8][13]=1;
maze[9][10] =maze[9][11]=maze[9][12]=maze[9][13]=maze[9][14]=1;
maze[10][14]=1;
//调用MAZE
MAZE(1,1);
System.out.println("(1,1)←入口");
System.out.println("总共走的步数为："+count);
}
}