穷举解决走迷宫问题

本人也算一个算法爱好者，喜欢学习各种算法，也喜欢用程序解决各种实际问题。

今天又碰到了一个走迷宫问题，于是特地花了点时间把该问题解决了。代码如下：

package com.bringwu.test.moze;

import java.util.ArrayList;
import java.util.List;

/**
 * @author bringwu
 * @date 2013-10-18 上午11:30:20
 */
public class Moze {
	
	private List<List<String>> paths = new ArrayList<List<String>>();
	
	private int count = 0;
	
	private int no = 2; 
	private int ye = 0; 
	
	private int endX = 0;
	private int endY = 0;
	
	private int[][] maze = {
			{ no, no, no, no, no, no, no },
			{ no, ye, ye, ye, ye, ye, no },
			{ no, ye, no, ye, ye, ye, no },
			{ no, ye, ye, no, ye, no, no },
			{ no, no, ye, no, ye, no, no },
			{ no, ye, ye, ye, ye, ye, no },
			{ no, no, no, no, no, no, no }
	};
	
	private int start(int startX,int startY,int endX,int endY){
		this.endX = endX;
		this.endY = endY;
		go(maze, startX, startY,new ArrayList<String>());
		return count;
	}
	
	private void go(int[][] maze, int startX,int startY,List<String> path ){
		//走到边界
		if (startX<0 || startY<0 || startX > maze[startY].length || startY > maze.length ) {
			return;
		}
		
		//走到终点
		if (startX == endX && startY == endY) {
			path.add(startX+","+startY);
			paths.add(path);
			count++;
			return;
		}
		
		if (maze[startX][startY]==no) {
			return ;
		}
		
		//设置当前位置不可走	
		maze[startX][startY] = no;
		
		//保存路径
		path.add(startX+","+startY);
		
		//向左
		maze = copyArray(maze);
		int next = startX - 1;
		go(maze, next, startY,new ArrayList<String>(path));
		
		//向右
		maze = copyArray(maze);
		next = startX + 1;
		go(maze, next, startY,new ArrayList<String>(path));
		
		//向上
		maze = copyArray(maze);
		next = startY - 1;
		go(maze, startX, next,new ArrayList<String>(path));
		
		//向下
		maze = copyArray(maze);
		next = startY + 1;
		go(maze, startX, next,new ArrayList<String>(path));
			
	}
	
	
	private int[][] copyArray(int maze[][]){
		int ylen = maze.length;
		int xlen = maze[0].length;
		int[][] mazeNew = new int[xlen][ylen];
		
		for (int i = 0; i < maze.length; i++) {
			for (int j = 0; j < maze[i].length; j++) {
				mazeNew[i][j] = maze[i][j];
			}
		}
		
		return mazeNew;
	}
	
	
	public static void main(String[] args) {
		
		Moze moze = new Moze();
		
		/*int[][] copyArray = moze.copyArray(moze.maze);
		for (int i = 0; i < moze.maze.length; i++) {
			for (int j = 0; j < moze.maze[i].length; j++) {
				if (copyArray[i][j] != moze.maze[i][j]) {
					System.err.println("不一致");
				}
			}
		}
		System.out.println("success copy!");*/
		
		System.out.println("总共有: "+moze.start(1, 1, 5, 5) +" 种走法！ ");
		
		System.out.println("走法如下：");

		for (int i = 0; i < moze.paths.size(); i++) {
			System.out.print("第"+(i+1)+"种: ");
			List<String> path = moze.paths.get(i);
			for (int j = 0; j < path.size(); j++) {
				System.out.print("["+path.get(j)+"]");
				if (j < path.size()-1) {
					System.out.print(" -> ");
				}
			}
			System.out.println();
		}
	}
}

走迷宫问题一般有两种方法解决。一种是穷举法，其实也就简单地递归遍历获取所有的路径，判断那条路径可以到达出口；另一种是回溯法，回溯法就是记录当前走过的路径，如果当前路径是死路，则不断回溯到上一步，直到找到其他方向可走。

以上只是用了穷举法，下一次有时间再用回溯法解决掉。