有关迷宫回溯问题的思考

有关迷宫回溯问题的思考

目前刚刚学到这个题目,还没有看算法讲解,先写下自己第一时间的思考
这个问题如果我来做,

首先用二维矩阵来模拟一个迷宫,0表示可以走,1表示不可以走,绘出迷宫轮廓

问题在于怎么走出迷宫,

目前的思路是这样的:

首先我会规定好它的遍历策略,先往哪个方向看,再往哪个方向看,有路就走,走不通再说.
这样肯定会导致一些问题,比如走的路是死胡同的情况,那怎么处理?
或许可以说记录一下走过的路,走的路是死路了,那我标记一下此路不通.但是在哪里标记,我又怎么判断我走的这条路不通的?

走不通的判断方法:我走过的路做好,当我走了一遍又回到了以前的地方说明之前走的方向有问题.
做标记:在我重新回到这个位置的时候我会标记上这个位置的某个方向(我走过的有标记的方向的路)是走不通的.

这就去学习前人的先进的思想

观后感

看完前人的回溯算法用于处理迷宫的理解

其实这个问题可以简化成一个重复性的问题,每一步都是一个探路的过程

简单理解为,一个人探路,当此路不通的时候传递信号告诉前面的自己,此路不通,并坐下标记,于是前面的自己就会选择他路

前面的疑惑:
1. 在哪里标记?
哪里走不通就在哪里标记,标记以后自己立地成墙,供上一层参考
2. 怎么判断我走的这条路不通的?
当四面都走不了的时候就是走不通咯

具体方法:

1. 墙为1,走过为2,死路为3
2. 探路,有路就走,并标记为2
3. 当发现此路不通(四周没有0),立地为碑,标记为3,并告诉前面的自己,此路不通(找路 return false)

因此个人理解本例中的递归,其实是一种可以自我复制的方法(找路),并且可以把当前的结果(找没找到路)反馈给上一级的一种手段

或者为了更清晰的理解,我认为他是一个树状结构,这样一下子就清晰了很多

操作代码

package recursion;

public class MiGong
{

	public static void main(String[] args)
	{
		int[][] map = new int[8][7];
		// 列墙
		for (int i = 0; i < 8; i++)
		{
			map[i][0] = 1;
			map[i][6] = 1;
		}
		// 行墙
		for (int i = 0; i < 7; i++)
		{
			map[0][i] = 1;
			map[7][i] = 1;
		}

		// 墙
		map[3][1] = 1;
		map[3][2] = 1;

		setWay(map, 1, 1);
		// 查看
		for (int i = 0; i < 8; i++)
		{
			for (int j = 0; j < 7; j++)
			{

				System.out.print(map[i][j] + " ");
			}
			System.out.println();
		}
	}

	/**
	 * 
	 * @param map 地图
	 * @param i   位置点
	 * @param j
	 * @return 找到路没有
	 */

	public static boolean setWay(int[][] map, int i, int j)
	{

		// 当前就是终点,直接找到了
		if (i == 6 && j == 5)
		{
			map[i][j] = 2;
			return true;
		}
		// 当前是个假路,直接报错
		if (map[i][j] != 0)
		{
			return false;
		} 
		//能走的路
		else
		{
			// 撒泡尿,标记为我到过此地,因为下次递归还要看
			map[i][j] = 2;

			// 向下找
			if (setWay(map, i + 1, j))
			{
				return true;
			}
			// 向右找
			else if (setWay(map, i, j + 1))
			{
				return true;
			}
			// 向上找
			else if (setWay(map, i - 1, j))
			{
				return true;
			}
			// 向左找
			else if (setWay(map, i, j - 1))
			{
				return true;
			}
			// 没找到
			else
			{
				// 标记为3
				map[i][j] = 3;
				return false;
			}
		}
	}

}