递归求解迷宫最短通道的总步长。输入一个迷宫，求从入口通向出口的可行路径中最短的路径长度。为简化问题，迷宫用二维数组 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]可以走通的路径上经历的最短的总步长。要求迷宫中只允许在水平或上下四个方向的空位上行走，走过的位置不能重复走。

输入格式:

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

输出格式:

若有可行的通道则输出一个整数，代表求出的通道的最短步长；若没有通道则输出"No solution"

输入样例:

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

上述输入代表的是如下这样一个迷宫：

其中红色的小方块是障碍物，蓝色的小方块是空位，白色的小圆连起来是一条从入口到出口的通道，两个圆之间代表一个步长。

输出样例:

14

代码如下：

import java.util.*;
public class Main {
	static int[][] maze;
	static int n;
	static int min;
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		min = n*n;
		maze = new int[n][n];
		for(int i=0;i<n;i++)
			for(int j=0;j<n;j++) 
				maze[i][j] = sc.nextInt();
		recursion(1, 1, 0);
		if(min==n*n)
			System.out.println("No solution");
		else 
			System.out.println(min);
	}
	public static void recursion(int x, int y, int count) {
		if(x==n-2 && y==n-2)
			min = Math.min(count, min);
		else {
			maze[x][y]=1;							//锁定，防止在递归的过程中再次递归已经访问过的结点导致无限循环
			if(y<n-1 && maze[x][y+1]==0) {
				recursion(x, y+1, count+1);			//右
			}
			if(x<n-1 && maze[x+1][y]==0) {
				recursion(x+1, y, count+1);			//下
			}
			if(x>1 && maze[x-1][y]==0) {
				recursion(x-1, y, count+1);			//上
			}
			if(y>1 && maze[x][y-1]==0) {
				recursion(x, y-1, count+1);			//左
			}
			maze[x][y]=0;							//当这个节点往后的节点已经都递归过了，则解除锁定
													//防止有其他路径也需要走这个节点但是已经不通
		}
	}
}

这个题说实话在我感觉并不是一个什么难题，但是我在这个题上浪费了很多的时间，原因很简单，对递归、dfs的理解不够。其实我感觉这个题最好的做法应该是用bfs，因为用bfs的话时间上的开销应该相对较少，并且如果用bfs的话也许我就不会遇到这么多的问题，我的一个同学就是用bfs做的，很成功，但是这周重点复习的毕竟是递归，所以我还是用递归写的。我提交的19遍不同改进程度的代码，最终都是最后一个测试点通不过，我找了一天多的时间都在想错误究竟出现在哪里，说实话我真的没有往“不是最短路线”上想，因为我自己造了几个会有多个通路的测试输入，输出的结果都正确，但是最终我发现，有一种情况我的代码通不过了，就是当两条路径有一个共用节点的时候，当最先递归的是一条路径后，另一条通路没法继续递归了，因为我在递归代码里加了一个maze[x][y]=1把已经被递归过的节点都锁住了，不会有一个节点被重复的递归，我又考虑的很久如果防止无限递归，又能保证不会出现两条通路最终只能随机找到一条的情况，我考虑了一夜，觉得也许是dfs做不到，也许这个算法只适用于只有一条路径或者没有通路的情况，但是到了今天早上，我突然想到了，在递归代码最后加了一个maze[x][y]=0，使得当递归往下完成以后解除对节点的锁定，提交最终全对了。

这个题目虽然让我浪费了很多的时间，但是真的很有收获，首先加深了对dfs、bfs和代码中一些细节方面的理解，其次我知道了对于这类迷宫问题到底怎么解决，如果我能在更早的时候就学到这个，也许今年3月份的蓝桥杯我那个迷宫的题就不会错了。