Java基础 4.10

1.递归调用应用实例-迷宫问题

public class MiGong {
	public static void main(String[] args) {
		//设置迷宫为8行7列
		//用数组表示迷宫 0表示无障碍 1表示有障碍
		int[][] map = new int[8][7];
		//将迷宫最上面和最下面的数全部置为1;
		for (int i = 0; i < 7; i++) {
			map[0][i] = 1;
			map[7][i] = 1;
		}

		//将迷宫最左边和最右边的数设置为1
		for (int i = 0; i < 8; i++) {
			map[i][0] = 1;
			map[i][6] = 1;
		}

		//设置迷宫第4行1-3列的数为1
		for (int i = 0; i < 3; i++) {
			map[3][i] = 1;
		}

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

		//打印迷宫现在的情况
		System.out.println("====初始迷宫情况====");
		for (int i = 0; i < map.length; i++) {
			for (int j = 0; j < map[i].length; j++) {
				System.out.print(map[i][j] + " ");
			}
			System.out.println();
		}

		Map myMap = new Map();
		myMap.findway(map, 1, 1);

		System.out.println("====当前迷宫情况====");
		for (int i = 0; i < map.length; i++) {
			for (int j = 0; j < map[i].length; j++) {
				System.out.print(map[i][j] + " ");
			}
			System.out.println();
		}
	}
}

class Map {
	public boolean findway(int[][] map, int i, int j) {
		//如果找到 返回true 否则返回false
		//i j 是老鼠的位置 初始化位置为(1, 1)
		//定义0表示无障碍 1表示有障碍 
		//2表示走过可以走 3表示走过发现是死路
		//当map[6][5] = 2时 就说明找到通路可以结束，否则就继续找
		//找路策略
		//下 右 上 左
		if (map[6][5] == 2) {//说明已经找到
			return true;
		} else {
			if (map[i][j] == 0) {//当前位置为0，说明可以走
				
				map[i][j] = 2;//假定可以走通

				//使用找路策略，来确定是否真的能走
				//下 右 上 左
				if (findway(map, i + 1, j)) {//先向下
					return true;
				} else if (findway(map, i, j + 1)) {//右
					return true;
				} else if (findway(map, i - 1, j)) {//上
					return true;
				} else if (findway(map, i, j - 1)) {//左
					return true;
				} else {
					map[i][j] = 3;
					return false;
				}
			
			} else {//map[i][j] = 1, 2, 3
				return false;
			}
		
		}
	} 
}

当当！是不是很神奇？其实就时关于递归的调用哈哈哈！ 

若换一种找路策略 又会变成什么样子呢？

public boolean findway2(int[][] map, int i, int j) {
	//如果找到 返回true 否则返回false
	//i j 是老鼠的位置 初始化位置为(1, 1)
	//定义0表示无障碍 1表示有障碍 
	//2表示走过可以走 3表示走过发现是死路
	//当map[6][5] = 2时 就说明找到通路可以结束，否则就继续找
	//找路策略
	//上 右 下 左
	if (map[6][5] == 2) {//说明已经找到
		return true;
	} else {
		if (map[i][j] == 0) {//当前位置为0，说明可以走
				
			map[i][j] = 2;//假定可以走通

			//使用找路策略，来确定是否真的能走
			//下 右 上 左
			if (findway(map, i - 1, j)) {//先向上
				return true;
			} else if (findway2(map, i, j + 1)) {//右
				return true;
			} else if (findway2(map, i + 1, j)) {//上
				return true;
			} else if (findway2(map, i, j - 1)) {//左
				return true;
			} else {
				map[i][j] = 3;
				return false;
			}
			
		} else {//map[i][j] = 1, 2, 3
			return false;
		}
		
	}
} 

测试回溯现象

map[2][2] = 1;

2.递归调用应用实例-汉诺塔问题

public class HanoiTower {
	public static void main(String[] args) {
		Solution tower = new Solution();
		tower.move(5, 'A', 'B', 'C');
	}
}

class Solution {
	//方法
	//num 表示要移动的个数, a, b, c 分别表示A B C
	public void move(int num, char a, char b, char c) {
		if (num == 1) {
			System.out.println(a + "->" + c);
		} else {
			//如果有多个盘，可以看成两个，最下面和上面的所有盘(num - 1)
			//先移动上面所有盘到B 借助C
			move(num - 1, a, c ,b);
			//把最下面的这个盘，移动到C
			System.out.println(a + "->" + c);
			//再把b塔的所有盘移动到C 借助A
			move(num - 1, b, a, c);
		}
	}
}