java怎样找出迷宫中所有路径_Java寻找迷宫路径

本文介绍了一种使用非递归的栈来解决迷宫路径查找问题的方法。通过创建Maze类和MazeStack类,利用Java实现从迷宫入口到出口的有效路径搜索。如果找不到路径,程序会输出"不存在有效路径"。
摘要由CSDN通过智能技术生成

问题:

/*

用非递归的栈来解决

用类来解决迷宫路径的查找问题,寻找一条从左上角迷宫入口

到右下角迷宫出口的一条有效路径,0代表可以行走,1代表不能行走,

找到,请输入最终的迷宫和路径信息, 找不到,请输出“不存在有效路径"。

*/

主函数:

package main;

import java.util.Scanner;

import maze.Maze;

public class MainTest {

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner in = new Scanner(System.in);

System.out.println("请输入迷宫大小:");

int size = in.nextInt();

Maze maze = new Maze(size);

System.out.println("请输入迷宫具体的路径信息:0表示路径可以走,1表示路径不能走:");

for(int i=0; i

for(int j=0; j

int data = in.nextInt();

maze.setMazeNode(i, j, data);

}

}

//开始寻找路径信息

maze.findPath();

//打印最终的路径信息

maze.showPath();

}

}

常量类:

package constant;

/**

* 描述: 定义项目所有的常量

*/

public interface Constant {

//路径的方向总数

int PATH_NUM = 4;

//右方向

int PATH_RIGHT = 0;

//下方向

int PATH_DOWN = 1;

//左方向

int PATH_LEFT = 2;

//上方向

int PATH_UP = 3;

//路径可以行走

int STATE_OK = 5;

//路径不能行走

int STATE_ERR = 6;

}

用来存放路径的类:

package maze;

import constant.Constant;

import node.MazeNode;

import stack.MazeStack;

public class Maze {

//存储迷宫路径信息

private MazeNode[][] mazePath;

//求解迷宫路径所需要的栈类型

private MazeStack stack;

//表示迷宫路径的大小

private int size;

/**

* 迷宫对象的初始化

* @param size

*/

public Maze(int size) {

// TODO Auto-generated constructor stub

this.size = size;

stack = new MazeStack();

mazePath = new MazeNode[this.size][this.size];

}

/**

* 给迷宫路径生成相应的节点

* @param i

* @param j

* @param data

*/

public void setMazeNode(int i, int j, int data) {

// TODO Auto-generated method stub

mazePath[i][j] = new MazeNode(i, j, data);

}

/**

* 开始寻找迷宫路径信息

*/

public void findPath() {

// TODO Auto-generated method stub

if(mazePath[0][0].getVal()!=0) {

System.out.println("there is no way!");

return;

}

fixPathState();

//开始寻找迷宫路径

int i=0;

int j=0;

stack.push(mazePath[i][j]);

while(!stack.empty()) {

i=stack.top().getX();

j=stack.top().getY();

if(i == this.size - 1 && j ==this. size - 1) {

break;

}

//向右

if(mazePath[i][j].getPath()[Constant.PATH_RIGHT] == Constant.STATE_OK) {

//将该节点 行走 状态设置为不行

mazePath[i][j].setPathState(Constant.PATH_RIGHT, Constant.STATE_ERR);

//将该节点 左边行走 状态设置为不行

mazePath[i][j+1].setPathState(Constant.PATH_LEFT, Constant.STATE_ERR);

将该节点右边节点入栈

stack.push(mazePath[i][j+1]);

continue;

}

//向下

if(mazePath[i][j].getPath()[Constant.PATH_DOWN] == Constant.STATE_OK) {

//将该节点 行走 状态设置为不行

mazePath[i][j].setPathState(Constant.PATH_DOWN, Constant.STATE_ERR);

//将该节点 上边行走状态设置为不行

mazePath[i+1][j].setPathState(Constant.PATH_UP, Constant.STATE_ERR);

//将该节点下边节点入栈

stack.push(mazePath[i+1][j]);

continue;

}

//向左

if(mazePath[i][j].getPath()[Constant.PATH_LEFT] == Constant.STATE_OK) {

//将该节点 行走 状态设置为不行

mazePath[i][j].setPathState(Constant.PATH_LEFT, Constant.STATE_ERR);

//将该节点 右边行走 状态设置为不行

mazePath[i][j-1].setPathState(Constant.PATH_RIGHT, Constant.STATE_ERR);

//将该节点左边节点入栈

stack.push(mazePath[i][j-1]);

continue;

}

//向上

if(mazePath[i][j].getPath()[Constant.PATH_UP] == Constant.STATE_OK) {

//将该节点 行走 状态设置为不行

mazePath[i][j].setPathState(Constant.PATH_UP, Constant.STATE_ERR);

//将该节点 下边行走 状态设置为不行

mazePath[i-1][j].setPathState(Constant.PATH_DOWN, Constant.STATE_ERR);

//将该节点上边节点入栈

stack.push(mazePath[i-1][j]);

continue;

}

stack.pop();

}

if(stack.empty()) {

System.out.println("no way");

}

}

/**

* 调整迷宫路径所有节点的行走状态

*/

private void fixPathState() {

// TODO Auto-generated method stub

for(int i=0; i

for(int j=0; j

// i, j

//向右

if(j

mazePath[i][j].setPathState(Constant.PATH_RIGHT, Constant.STATE_OK);

}

//向下

if(i

mazePath[i][j].setPathState(Constant.PATH_DOWN, Constant.STATE_OK);

}

//向左

if(j>0 && mazePath[i][j-1].getVal() == 0) {

mazePath[i][j].setPathState(Constant.PATH_LEFT, Constant.STATE_OK);

}

//向上

if(i>0 && mazePath[i-1][j].getVal() == 0) {

mazePath[i][j].setPathState(Constant.PATH_UP, Constant.STATE_OK);

}

}

}

}

/**

* 打印迷宫路径信息

*/

public void showPath() {

// TODO Auto-generated method stub

while(!stack.empty()) {

int i=stack.top().getX();

int j=stack.top().getY();

this.setMazeNode(i, j, 7);

stack.pop();

}

System.out.println("迷宫路径信息(路径可以走 7表示):");

for(int i=0 ; i

for(int j=0;j

System.out.print(this.mazePath[i][j].getVal()+" ");

}

System.out.println();

}

}

}

迷宫路径节点的类型信息类:

package node;

import constant.Constant;

public class MazeNode {

//存储节点的值

private int val;

//存储节点的坐标

private int x;

private int y;

//存储节点四个方向的行走状态

private int[] path;

/**

* 节点对象的初始化

* @param i

* @param j

* @param data

*/

public MazeNode(int i, int j, int data) {

// TODO Auto-generated constructor stub

this.x = i;

this.y = j;

this.val = data;

//初始化节点的四个方向行走信息的时候,都初始化成不能走

path = new int[Constant.PATH_NUM];

for(int k=0; k

path[k] = Constant.STATE_ERR;

}

}

public int getVal() {

return val;

}

public void setVal(int val) {

this.val = val;

}

public int getX() {

return x;

}

public void setX(int x) {

this.x = x;

}

public int getY() {

return y;

}

public void setY(int y) {

this.y = y;

}

public int[] getPath() {

return path;

}

public void setPath(int[] path) {

this.path = path;

}

/**

* 把节点相应的方向path,的行走状态,修改为state

* @param pathRight

* @param stateOk

*/

public void setPathState(int pathid, int state) {

// TODO Auto-generated method stub

this.path[pathid] = state;

}

}

迷宫需要的顺序栈结构 (内存可增长):

package stack;

import java.util.Arrays;

import node.MazeNode;

public class MazeStack {

private MazeNode[] stack;

private int top;

public MazeStack(){

this.stack = new MazeNode[10];

this.top = 0;

}

/**

* 入栈

* @param val

*/

public void push(MazeNode mazeNode) {

if(full()) {

this.stack=Arrays.copyOf(this.stack, 2*this.top);

}

this.stack[this.top]=mazeNode;

this.top++;

}

/**

* 出栈

*/

public void pop() {

if(empty()) {

return;

}

this.top--;

}

/**

* 返回栈顶元素

* @return

*/

public MazeNode top() {

return this.stack[this.top-1];

}

/**

* 判断栈空

* @return

*/

public boolean empty() {

return this.top == 0;

}

/**

* 判断栈满

* @return

*/

public boolean full() {

return this.top == this.stack.length;

}

}

运行结果:

请输入迷宫大小:

5

请输入迷宫具体的路径信息:0表示路径可以走,1表示路径不能走:

0 0 0 0 1

1 0 1 0 1

0 0 1 1 1

0 1 0 0 1

0 0 0 0 0

迷宫路径信息(路径可以走 7表示):

7 7 0 0 1

1 7 1 0 1

7 7 1 1 1

7 1 0 0 1

7 7 7 7 7

问题描述: 以一个m*n的长方阵表示迷宫,0和1分别表示迷宫的通路和障碍。设计一个程序,对任意设定的迷宫,求出从入口(0,0)到出口(m-1,n-1)的通路和通路总数,或得出没有通路的结论。例如下图, 0(入口) 1 0 1 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0(出口) 从入口到出口有6条不同的通路。 而下图: 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0 0 1 1 0 1 0 1 1 1 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 1 1 1 1 0 0 1 1 1 0 0 0 1 0 1 1 1 0 0 0 0 0 0 从入口到出口则没有通路。 算法设计: 给定一个m*n的长方阵表示迷宫,设计算法输出入口到出口的通路和通路总数,或得出没有通路的结论。 算法提示: 和皇后问题与分书问题类似。可以用二维数组存储迷宫数据,对于迷宫任一位置,均可约定有东、南、西、北四个方向可通。从当前位置a(用(x,y)表示一个位置,假定它是以向右的x轴和向下的y轴组成的平面上的一个点)出发依次尝试四个方向是否有路,若某个方向的位置b可通,则按照同样的方法继续从b出发寻找。若到达出口,则找到一条通路。 数据输入: 由文件input.txt 提供输入数据。第一行是m和n的值,空格分隔,其后共m行。每行有n个数字,数和数之间用空格分隔。 结果输出: 将计算出的所有从入口到出口的通路输出到文件output.txt 。若没有通路,则将0写入文件
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值