#迷宫问题（DFS＋回溯）

Time Limit: 1000MS
Memory Limit: 65536K
Total Submissions: 38016
Accepted: 21311

Description

定义一个二维数组：

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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

Input

一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。

Output

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

Sample Input

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

Sample Output

(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

问题链接：https://vjudge.net/problem/19699/origin
问题简述：'1’表示墙壁，'0’表示可行，在题目给出的5*5迷宫里，找到从左上角到右下角的最短路径。
问题分析：DFS + 回溯
程序分析：首先定义四个搜索的方向，建立一个数组记录路径的长度以及踩点，每走一步后将‘0’改成‘1’表示不往回走，生成所有可行的路径后，比较找出最短的路径，并依次输出其路线。

ac代码如下：

#include<iostream>
using namespace std;
int dec[4][2] = { {1,0},{0,1},{-1,0},{0,-1} };            //定义四个方向
int maze[5][5], cross[25][2], total = 0, n,min;
struct Road {
	int r[30][2], step;    //记录生成路径 
}roads[100];
void dfs(int x, int y, int n)                   //生成路径
{
	if (x == 4 && y == 4)
	{
		roads[total].step = n;
		for (int i = 1; i < n; i++)
		{
			roads[total].r[i][0] = cross[i][0];
			roads[total].r[i][1] = cross[i][1];
		}
		total++;
		return;
	}
}
int main()
{
	for (int i = 0; i < 5; i++)
		for (int j = 0; j < 5; j++)
			cin >> a[i][j];
	dfs(0, 0, 1);                  //生成所有路径
	int min = 0;
	for (int i = 0; i < 4; i++)
	{
		int xn = x + dec[i][0], yn = y + dec[i][1];
		if (xn >= 0 && yn >= 0 && xn < 5 && yn < 5 && maze[xn][yn] != 0)
		{
			maze[xn][yn] = 1;               //置‘1’
			cross[n][0] = xn;
			cross[n][1] = yn;
			dfs(xn, yn, n + 1);
			maze[xn][yn] = 0;               //重新置‘0’
		}
	}
	for (int i = 1; i < total; i++)
		if (roads[i].step < roads[min].step)
			min = 1;
	for (int i = 0; i < roads[min].step; i++)
		cout << "(" << roads[min].r[i][0] << "," << roads[min].r[i][1] << ")" << endl;
}