递归实现迷宫问题2(查找最短路径)-作业

最新推荐文章于 2022-07-23 11:11:59 发布
最新推荐文章于 2022-07-23 11:11:59 发布
阅读量425 收藏 1
点赞数
分类专栏： Java Java数据结构和算法 文章标签： java 递归法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44696662/article/details/116122989
版权

代码

package com.atguitu.recursion;

/**
 * 
 * @author little_pine
 * 当前进度: 全部完成
 * 
 */
public class MiGongSearchShortestPath {

	public static void main(String[] args) {
		// 先创建一个二维数组, 模拟迷宫
		// 地图
		int[][] map = new int[8][7];
		// 创建地图
		setMap(map);
		// 输出初始地图
		System.out.println("初始地图的情况");
		showMap(map);

		/*
		 * 思路: 1. 用一个数组表示不同的策略 2. for循环将每个策略走一遍 3. 将每种策略的 2 节点进行统计,最少的那个 2 节点个数就是最短路径
		 */

		// 用数组表示不同的策略
		int[] arr = new int[24];
		String[] array = { "1234", "1243", "1423", "4123", "1324", "1342", "1432", "4132", "3124", "3142", "3412",
				"4312", "2134", "2143", "2413", "4213", "2314", "2341", "2431", "4231", "3214", "3241", "3421",
				"4321" };

		// 节点计数数组
		int[] count = new int[24];

		// for循环将每个策略走一遍
		for (int i = 0; i < 24; i++) {
			arr[i] = i;
			chooseMethod(arr[i], map);
			// 每执行完一次就对地图进行有效节点计数, 并将地图重置
			// 对有效节点 2 进行计数
			count[i] = countUsefulNode(map);
			// 将地图进行重置
			setMap(map);
		}

		// 取出最小节点数, 并返回其相应的策略和路径
		// 取出策略
		int method = getMinNodes(count);
		// 展示使用的策略及其取出的路径
		chooseMethod(method, map);
		System.out.println("上(1), 下(2), 左(3), 右(4)");
		System.out.println("最短路径使用的策略是:");
		System.out.println(method + ":" + array[method]);
		// 显示属于最短路径的策略
		System.out.println("属于最短路径的策略有:");
		for (int i = 0; i < count.length; i++) {
			if (count[i] == count[method]) {
				System.out.println(i + ":" + array[i]);
			}
		}
		// 显示最短路径地图
		System.out.println("最短路径的地图情况:");
		showMap(map);

		// 显示count,显示各个策略及其对应的节点数
		for (int i = 0; i < count.length; i++) {
			System.out.println(i + ":" + array[i] + ":" + count[i]);
		}
	}

	// 迷宫展示方法
	public static void showMap(int[][] map) {
		for (int i = 0; i < 8; i++) {
			for (int j = 0; j < 7; j++) {
				System.out.print(map[i][j] + " ");
			}
			System.out.println();
		}
	}

	// 取出最小节点数, 返回对应策略方法
	public static int getMinNodes(int[] count) {
		int min = 99;
		int method = 0;
		for (int i = 0; i < count.length; i++) {
			if (count[i] < min) {
				min = count[i];
				method = i;
			}
		}
		return method;
	}

	// 节点计数方法
	public static int countUsefulNode(int[][] map) {
		int count = 0;
		for (int i = 0; i < 8; i++) {
			for (int j = 0; j < 7; j++) {
				if (map[i][j] == 2) {
					count++;
				} else {
					continue;
				}
			}
		}
		return count;
	}

	// 迷宫地图创建和重置方法
	public static void setMap(int[][] map) {
		// 先将地图全部重置为0
		for (int i = 0; i < 8; i++) {
			for (int j = 0; j < 7; j++) {
				map[i][j] = 0;
			}
		}

		// 创建迷宫, 使用1 表示墙
		// 上下全部置为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;
		}

		// 设置挡板,1表示
		map[3][1] = 1;
		map[3][2] = 1;
	}

	// 调用不同的策略方法
	// 上(1), 下(2), 左(3), 右(4)
	public static void chooseMethod(int i, int map[][]) {
		switch (i) {
		case 0:
			_1234(map, 1, 1);
			break;
		case 1:
			_1243(map, 1, 1);
			break;
		case 2:
			_1423(map, 1, 1);
			break;
		case 3:
			_4123(map, 1, 1);
			break;
		// ====
		case 4:
			_1324(map, 1, 1);
			break;
		case 5:
			_1342(map, 1, 1);
			break;
		case 6:
			_1432(map, 1, 1);
			break;
		case 7:
			_4132(map, 1, 1);
			break;
		// ====
		case 8:
			_3124(map, 1, 1);
			break;
		case 9:
			_3142(map, 1, 1);
			break;
		case 10:
			_3412(map, 1, 1);
			break;
		case 11:
			_4312(map, 1, 1);
			break;
		// ====
		case 12:
			_2134(map, 1, 1);
			break;
		case 13:
			_2143(map, 1, 1);
			break;
		case 14:
			_2413(map, 1, 1);
			break;
		case 15:
			_4213(map, 1, 1);
			break;
		// ====
		case 16:
			_2314(map, 1, 1);
			break;
		case 17:
			_2341(map, 1, 1);
			break;
		case 18:
			_2431(map, 1, 1);
			break;
		case 19:
			_4231(map, 1, 1);
			break;
		// ====
		case 20:
			_3214(map, 1, 1);
			break;
		case 21:
			_3241(map, 1, 1);
			break;
		case 22:
			_3421(map, 1, 1);
			break;
		case 23:
			_4321(map, 1, 1);
			break;
		default:
			break;
		}
	}

	// 方向分为上下左右,所以可以存在24种策略方式

	// 将上下左右进行封装

	// 向上
	public static int up(int i) {
		return i - 1;
	}

	// 向下
	public static int down(int i) {
		return i + 1;
	}

	// 向左
	public static int left(int j) {
		return j - 1;
	}

	// 向右
	public static int right(int j) {
		return j + 1;
	}

	// 使用递归回溯来给小球找路
	// 说明
	// 1. map 表示地图
	// 2. i,j 表示从地图的那个位置开始出发(1,1)
	// 3. 如果小球能到 map[6][5] 位置, 则说明通路找到
	// 4. 约定: 当map[i][j]
	// 0 表示该点没有走过, 1 表示墙, 2 表示通路可以走, 3 表示该点已经走过,但是走不通
	// 5. 在走迷宫时, 需要确定一个策略(方法) 下->右->上->左, 如果该点走不通, 再回溯
	/**
	 * 
	 * @param map 表示地图
	 * @param i   从哪个位置开始找
	 * @param j
	 * @return 如果找到通路,就返回true,否则返回false
	 */

	// 上(1), 下(2), 左(3), 右(4)

	// 24种策略:

	// 1234,上下左右
	public static boolean _1234(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_1234(map, up(i), j)) {
					return true;
				} else if (_1234(map, down(i), j)) {
					return true;
				} else if (_1234(map, i, left(j))) {
					return true;
				} else if (_1234(map, i, right(j))) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

	// 1243,上下右左
	public static boolean _1243(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_1243(map, up(i), j)) {
					return true;
				} else if (_1243(map, down(i), j)) {
					return true;
				} else if (_1243(map, i, right(j))) {
					return true;
				} else if (_1243(map, i, left(j))) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

	// 1423,上右下左
	public static boolean _1423(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_1423(map, up(i), j)) {
					return true;
				} else if (_1423(map, i, right(j))) {
					return true;
				} else if (_1423(map, down(i), j)) {
					return true;
				} else if (_1423(map, i, left(j))) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

	// 4123,右上下左
	public static boolean _4123(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_4123(map, i, right(j))) {
					return true;
				} else if (_4123(map, up(i), j)) {
					return true;
				} else if (_4123(map, down(i), j)) {
					return true;
				} else if (_4123(map, i, left(j))) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

//	======
	// 1324,上左下右
	public static boolean _1324(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_1324(map, up(i), j)) {
					return true;
				} else if (_1324(map, i, left(j))) {
					return true;
				} else if (_1324(map, down(i), j)) {
					return true;
				} else if (_1324(map, i, right(j))) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

	// 1342,上左右下
	public static boolean _1342(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_1342(map, up(i), j)) {
					return true;
				} else if (_1342(map, i, left(j))) {
					return true;
				} else if (_1342(map, i, right(j))) {
					return true;
				} else if (_1342(map, down(i), j)) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

	// 1432,上右左下
	public static boolean _1432(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_1432(map, up(i), j)) {
					return true;
				} else if (_1432(map, i, right(j))) {
					return true;
				} else if (_1432(map, i, left(j))) {
					return true;
				} else if (_1432(map, down(i), j)) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

	// 4132,右上左下
	public static boolean _4132(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_4132(map, i, right(j))) {
					return true;
				} else if (_4132(map, up(i), j)) {
					return true;
				} else if (_4132(map, i, left(j))) {
					return true;
				} else if (_4132(map, down(i), j)) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

//	======
	// 3124,左上下右
	public static boolean _3124(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_3124(map, i, left(j))) {
					return true;
				} else if (_3124(map, up(i), j)) {
					return true;
				} else if (_3124(map, down(i), j)) {
					return true;
				} else if (_3124(map, i, right(j))) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

	// 3142,左上右下
	public static boolean _3142(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_3142(map, i, left(j))) {
					return true;
				} else if (_3142(map, up(i), j)) {
					return true;
				} else if (_3142(map, i, right(j))) {
					return true;
				} else if (_3142(map, down(i), j)) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

	// 3412,左右上下
	public static boolean _3412(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_3412(map, i, left(j))) {
					return true;
				} else if (_3412(map, i, right(j))) {
					return true;
				} else if (_3412(map, up(i), j)) {
					return true;
				} else if (_3412(map, down(i), j)) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

	// 4312,右左上下
	public static boolean _4312(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_4312(map, i, right(j))) {
					return true;
				} else if (_4312(map, i, left(j))) {
					return true;
				} else if (_4312(map, up(i), j)) {
					return true;
				} else if (_4312(map, down(i), j)) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

//	======
	// 2134,下上左右
	public static boolean _2134(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_2134(map, down(i), j)) {
					return true;
				} else if (_2134(map, up(i), j)) {
					return true;
				} else if (_2134(map, i, left(j))) {
					return true;
				} else if (_2134(map, i, right(j))) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

	// 2143,下上右左
	public static boolean _2143(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_2143(map, down(i), j)) {
					return true;
				} else if (_2143(map, up(i), j)) {
					return true;
				} else if (_2143(map, i, right(j))) {
					return true;
				} else if (_2143(map, i, left(j))) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

	// 2413, 下右上左
	public static boolean _2413(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				// 如果当前这个点还没有走过
				// 按照策略 下->右->上->左 走
				map[i][j] = 2;// 假定该点时可以走通的
				if (_1234(map, down(i), j)) {
					// 向下走
					return true;
				} else if (_1234(map, i, right(j))) {
					// 向右走
					return true;
				} else if (_1234(map, up(i), j)) {
					// 向上走
					return true;
				} else if (_1234(map, i, left(j))) {
					// 向左走
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

	// 4213,右下上左
	public static boolean _4213(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_4213(map, i, right(j))) {
					return true;
				} else if (_4213(map, down(i), j)) {
					return true;
				} else if (_4213(map, up(i), j)) {
					return true;
				} else if (_4213(map, i, left(j))) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

//	======
	// 2314,下左上右
	public static boolean _2314(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_2314(map, down(i), j)) {
					return true;
				} else if (_2314(map, i, left(j))) {
					return true;
				} else if (_2314(map, up(i), j)) {
					return true;
				} else if (_2314(map, i, right(j))) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

	// 2341,下左右上
	public static boolean _2341(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_2341(map, down(i), j)) {
					return true;
				} else if (_2341(map, i, left(j))) {
					return true;
				} else if (_2341(map, i, right(j))) {
					return true;
				} else if (_2341(map, up(i), j)) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

	// 2431,下右左上
	public static boolean _2431(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_2431(map, down(i), j)) {
					return true;
				} else if (_2431(map, i, right(j))) {
					return true;
				} else if (_2431(map, i, left(j))) {
					return true;
				} else if (_2431(map, up(i), j)) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

	// 4231,右下左上
	public static boolean _4231(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_4231(map, i, right(j))) {
					return true;
				} else if (_4231(map, down(i), j)) {
					return true;
				} else if (_4231(map, i, left(j))) {
					return true;
				} else if (_4231(map, up(i), j)) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

//	======
	// 3214,左下上右
	public static boolean _3214(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_3214(map, i, left(j))) {
					return true;
				} else if (_3214(map, down(i), j)) {
					return true;
				} else if (_3214(map, up(i), j)) {
					return true;
				} else if (_3214(map, i, right(j))) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

	// 3241,左下右上
	public static boolean _3241(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_3241(map, i, left(j))) {
					return true;
				} else if (_3241(map, down(i), j)) {
					return true;
				} else if (_3241(map, i, right(j))) {
					return true;
				} else if (_3241(map, up(i), j)) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

	// 3421,左右下上
	public static boolean _3421(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_3421(map, i, left(j))) {
					return true;
				} else if (_3421(map, i, right(j))) {
					return true;
				} else if (_3421(map, down(i), j)) {
					return true;
				} else if (_3421(map, up(i), j)) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

	// 4321,右左下上
	public static boolean _4321(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			// 通路已经找到
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;// 假定该点时可以走通的
				if (_4321(map, i, right(j))) {
					return true;
				} else if (_4321(map, i, left(j))) {
					return true;
				} else if (_4321(map, down(i), j)) {
					return true;
				} else if (_4321(map, up(i), j)) {
					return true;
				} else {
					// 说明该点时走不通的,是死路
					map[i][j] = 3;
					return false;
				}
			} else {
				// 如果map[i][j] != 0, 可能是1, 2, 3
				return false;
			}
		}
	}

}

结果截图

在这里插入图片描述在这里插入图片描述在这里插入图片描述

「已注销」
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
递归和栈求解迷宫的最短路径
persistence_s的博客
04-29 2409
采用递归的方式求最短路径 1、用一个栈专门用来保存有效的路径 2、再用一个栈来辅助保存所有走过的路径。 3、然后再用一个栈用来保存最短的路径 4、如果每次找到了出口，那么必然有两个栈一个保存了所有走过的路径，一个保存了通路的路径 5、于是每找到一次出口，那么开始进行比较，如果当前最短路径中所保存的每个坐标的个数如果大于本次通路的路径，那么就将最短路径中的所有数据出栈，并将本次通路的路径放入
数据结构------递归+迷宫问题+最短路径问题解决思路
萌新Java工程师
12-20 1934
递归 场景以及概念 迷宫回溯问题 简单的说:递归就是方法自己调用自己，每次调用时传入不同的变量.递归有助于编程者解决复杂的问题，同时可以让代码变得简洁。 调用机制 1.打印问题 package com.wang.Recursion; /** * @author 王庆华 * @version 1.0 * @date 2020/12/20 9:30 * @Description TODO * @pojectname 递归代码 */ public class RecursionTest {
迷宫回溯问题递归最短路径
元气少女帕吉
01-11 418
public class Labyrinth { public static void main(String[] args) { //创建一个二维数组，模拟迷宫 //地图 int[][] map = new int[8][7]; //使用1表示墙，先把上下全部置为1 for (int i = 0; i < 7; i++) { map[0][i] = 1; map[7][i] = 1; } //左右全部置为1 for(int i = 0; i < 8
递归-迷宫最短路径问题
jiamaa的博客
09-23 575
1.这是迷宫最短路径的代码以及效果图，为了备忘，mark一下 效果图： 代码： package recursiontest; import java.util.ArrayList; import java.util.List; public class MiGong2 { public static void main(String[] args) { MiGongCore mi = new MiGongCore(); mi.play(); } } /** * * @Descrip
求迷宫的最短路径
wyhllk的专栏
05-29 1517
迷宫的表示是一个N×M的二位数组，左上角的位置(0,0)是入口，右下角的位置(N-1,M-1)是迷宫的出口，其中的1表示迷宫不能走，0表示可以行走，本文使用类似的A*算法来进行寻路。 首先是定义个一个点的类，Poin表示迷宫的每个点的位置，如下： package wyhllk.algorithm; /** * @author wyhllk * */ public class Point
【计算机毕业设计】C语言项目源码 c语言支持自己创建迷宫，并求解最短路径
03-15
标题中的“【计算机毕业设计】C语言项目源码 c语言支持自己创建迷宫，并求解最短路径”表明这是一个基于C语言的计算机程序，用于生成自定义迷宫并寻找其最短路径。这个项目可能涉及的数据结构、算法以及编程技术是...
C语言实例开发源码——c语言支持自己创建迷宫，并求解最短路径.zip
10-25
在“迷宫2”这个文件中，可能包含了实现迷宫生成和最短路径查找的具体代码。源码可能包括以下几个部分： 1. 迷宫生成：迷宫生成可以采用随机算法，如Prim's或Kruskal's算法，或者使用预定义的模板。代码会涉及...
迷宫问题（路径搜索递归）1
08-03
在这个题目中，我们正在解决一个经典的计算机科学问题——迷宫问题。迷宫通常表示为一个二维数组，...通过这段代码，我们可以学习到如何利用DFS解决迷宫问题，并理解在实际编程中如何实现路径搜索和最短路径的查找。
算法分析与设计查找迷宫的最短路径(深度算法)借鉴.pdf
11-29
【算法分析与设计查找迷宫的最短路径(深度算法)】 迷宫求解问题是一个经典的计算机科学问题，它涉及到路径寻找、决策和优化。在本文中，我们将深入探讨如何利用深度优先搜索（DFS）算法来寻找迷宫中的最短路径。...
基于C++迷宫问题 计算最短距离
12-19
在本文中，我们将深入探讨如何使用C++解决迷宫问题，并计算出从起点到终点的最短路径。迷宫问题是一种经典的图论问题，通常涉及深度优先搜索（DFS）或广度优先搜索（BFS）算法。我们还将讨论一些基本的C++知识以及...
迷宫 最短路径及所有路径的问题
12-06
迷宫问题，完成的是一个现实中的迷宫游戏求最短路径及所有路径的问题，本程序相对于航班信息查询系统比较简单，主要包含使用系统迷宫（可以选择迷宫的入口和出口，并输出所有路径和最短路径），使用新建迷宫（可以自己设计迷宫的大小，及所有通路，可以选择迷宫的入口和出口，并输出所有路径和最短路径），用到了栈的使用，如栈的创建、入栈、出栈等函数功能。
C++利用递归实现走迷宫
08-19
主要为大家详细介绍了C++利用递归实现走迷宫，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
迷宫问题的递归解决办法
07-26
把主函数写的比较简，方便大家根据具体情况要求，进行改动~
【数据结构】求多出口带环迷宫的最短路径（递归版本）
Qregi的博客
02-03 417
Maze.h #pragma once #include typedef struct Pos{ int _Row; int _COL; }Pos; typedef struct Maze{ struct Pos pos; }Maze; Maze.c #define _CRT_SECURE_NO_WARNINGS 1 #include #include"Maze.
用递归实现迷宫并且比较最短路径(java)
m0_56184347的博客
07-17 674
文章目录迷宫的制作初始化二维数组中的数值利用递归实现路径搜索定义判断节点是否可以通过的方法比较最短路径测试代码结果 迷宫的制作 迷宫如下，可以看成一个二维数组，黑色的代表是墙，不能通过，黄色的代表迷宫的起点，红的代表终点。 初始化二维数组中的数值 令：1代表墙，表示不能通过 int [][] map=new int[7][8]; int plan1=0; int plan2=0; for(int i=0;i<7;i++){ m
最短路径算法（递归）
m0_47333020的博客
07-23 385
代码】最短路径算法（尝试）
复杂迷宫问题的递归实现以及最短路径
stay_the_course的博客
03-12 4853
复杂迷宫就是有多条通路的迷宫，而且要求解最短路的话就要用递归集合栈，用递归探测，寻找所有通路，用栈保存所走过的路径，具体方法为： （1）从当前点为起点探测由它开始能前进的点（这里的探测方向为上，有，左，下）； （2）找到能前进的点之后，首先将这个点的坐标压入栈（path）中保存起来，并将这个点的值赋为前一个点的值加1；递归调用这个函数，继续探测； （3）当前结点不能前进之后，将path中的点弹
【数据结构】-------求多出口迷宫的最短路径
daboluo521的博客
04-20 582
上面我们已经写过递归和非递归来实现求解迷宫的问题，今天我们就在递归的基础上实现多条通路，最短问题。 初始化最短路径地图 ///////////////////////////////////////////////// //////////////多通路最短路径///////////////////// //////////////////////////////////////////...
J - 迷宫问题（bfs求最短路径+递归输出最短路径）
pursuit的博客
07-25 939
迷宫问题
实现一下迷宫问题递归算法c++
最新发布
04-15
// 找到终点，返回路径长度（用于查找最短路径时使用） path[x][y] = 1; return 1; } if (maze[x][y] == 0 || path[x][y] == 1) { // 当前位置不能通行或已经在路径上 return 0; } path[x][y] = 1; // ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值