Realización del proyecto Maze

Introducción al proyecto:

 Un laberinto de cuadrículas consta de n filas ym columnas de celdas, y cada compuesto es un claro (representado por 0) o un obstáculo (representado por 1). Su tarea es encontrar una secuencia en movimiento desde el punto de inicio hasta el punto final, que solo puede moverse hacia arriba, hacia abajo, hacia la izquierda y hacia la derecha hasta las celdas adyacentes. En ningún momento puedes estar en una celda con obstáculos, ni puedes salir del laberinto. El punto de partida es la esquina superior izquierda y la esquina inferior derecha del punto final.

Función del proyecto:

1. Encuentra un camino válido desde la entrada del laberinto en la esquina superior izquierda hasta la salida del laberinto en la esquina inferior derecha .
2. 0 significa transitable, 1 significa incapaz de caminar y 8 significa sendero para caminar.
3. Si lo encuentra, envíe la información final del laberinto y la ruta. Si lo encuentra, indique que no hay una ruta válida.

Puntos de conocimiento del proyecto:

 Implementado utilizando ideas orientadas a objetos de Java, matrices bidimensionales y pilas no recursivas

Idea de proyecto:

1. Definir una matriz bidimensional de tipo de nodo de laberinto (MazeNode)
2. Inicialice el valor en cada cuadrícula. Almacene objetos para cada cuadrícula de una matriz bidimensional. El valor del objeto solo puede ser 0 (la cuadrícula actual se puede mover) o 1 (la cuadrícula actual no se puede mover)
3. Inicialice si las cuatro direcciones (sureste, noroeste) de cada cuadrícula son transitables. De acuerdo con los valores de las cuadrículas en las cuatro direcciones alrededor del nodo actual, juzgue si las cuatro direcciones del nodo actual se pueden caminar (0 es para ir, 1 no para ir).
4. Empiece a caminar por el laberinto. Utilice la operación de pila para registrar el camino a pie, empuje el elemento superior izquierdo hacia la pila, juzgue en qué dirección puede ir el elemento superior de la pila actual y empuje una de las direcciones posibles hacia la pila hasta que el elemento inferior derecho se detenga. El camino recorrido se guarda en la pila.
   Nota: Si encuentra el problema de entrar en un callejón sin salida, debe ser el elemento superior de la pila en este momento y el elemento superior de la pila no puede caminar en las cuatro direcciones. En este momento, sáquelo del apilar y elegir una nueva dirección para volver a colocarlo en la pila hasta que el elemento de la esquina inferior derecha se detenga.

Datos de prueba y análisis:

1. Ve directamente

2. Necesito regresar y encontrar una nueva forma.

3. En ninguna parte, regrese hasta que la pila esté vacía

Código:

Maze.java

import java.util.Scanner;
import java.util.Stack;

public class Maze {
    
    
	private MazeNode[][] mazeNodes;//节点数组
	private int row;//数组的行个数
	private int column;//列
	private Stack<MazeNode> stack;

	
	public Maze( int row, int column) {
    
    
		this.row = row;
		this.column = column;
		
		mazeNodes = new MazeNode[row][column];
		stack=new Stack<MazeNode>();
	}
	

	//初始化value值
	public  void initValue() {
    
    
		System.out.println("请输入迷宫路径：（0表示可走，1表示不可走）");
		Scanner sc=new Scanner(System.in);
		for(int i=0;i<row;i++)
		  for(int j=0;j<column;j++)
			{
    
    
				mazeNodes[i][j]=new MazeNode(sc.nextInt(),i,j);
			}
	}
	
	
	//初始化每个结点的行走状态
	//--------->j  |
	//    上北                   |
	//左西               右东      \|/
	//    下南                    i				
	private void initWayState() {
    
    
		for(int i=0;i<row;i++)
		   for(int j=0;j<column;j++){
    
    
			    //为1像墙不可达，故不用 判断墙的四周
			   //四周都要判断，不要用else if
				if(mazeNodes[i][j].getValue() == 0) {
    
    
					//东 为0可走就置able）
					if(j+1<column && mazeNodes[i][j+1].getValue() == 0) {
    
    
						mazeNodes[i][j].setWayState(Maze_Constant.WAY_EAST,Maze_Constant.WAY_ABLE);
					}
					//南
					if(i+1<row && mazeNodes[i+1][j].getValue() == 0) {
    
    
						mazeNodes[i][j].setWayState(Maze_Constant.WAY_SOUTH,Maze_Constant.WAY_ABLE);
					}
					//西
					if(j-1>=0 && mazeNodes[i][j-1].getValue() == 0) {
    
    
						mazeNodes[i][j].setWayState(Maze_Constant.WAY_WEST,Maze_Constant.WAY_ABLE);
					}
					//北
					if(i-1>=0 && mazeNodes[i-1][j].getValue() == 0) {
    
    
						mazeNodes[i][j].setWayState(Maze_Constant.WAY_NORTH,Maze_Constant.WAY_ABLE);
					}
				}		
			}
	}
	
	
	//从左上角找右下角的出路
	//找到一条就行
	public void goMaze() {
    
    
		initValue();
		initWayState();
		
		if(mazeNodes[0][0].getValue()!=0) {
    
    
			System.out.println("没有路径");
			return;
		}
		
		//用栈保存行走路线信息
		stack.push(mazeNodes[0][0]);
		while(!stack.isEmpty()) {
    
    
			MazeNode top=stack.peek();//获取栈顶端的元素
			//到右下角了
			if(top.getxPos()==row-1 && top.getyPos()==column-1) {
    
    
				break;
			}
			
			//获取栈顶元素位置
			int xPos=top.getxPos();
			int yPos=top.getyPos();
			
			//不用看越界，已经初始化过各方向状态了
			//避免成环
			//注意每次while循环  只走一步路，所以搭配else if
			if(top.getWayState(Maze_Constant.WAY_EAST)) {
    
    
				//向东走
				stack.push(mazeNodes[xPos][yPos+1]);
				
				//将当前结点（x,y）的走过方向(东)封掉
				mazeNodes[xPos][yPos].setWayState(Maze_Constant.WAY_EAST, Maze_Constant.WAY_DISABLE);
				//将东边结点（x,y+1）的回路，西边方向封掉
				mazeNodes[xPos][yPos+1].setWayState(Maze_Constant.WAY_WEST, Maze_Constant.WAY_DISABLE); 
			}else if(top.getWayState(Maze_Constant.WAY_SOUTH)) {
    
    
				//南
				stack.push(mazeNodes[xPos+1][yPos]);
				
				mazeNodes[xPos][yPos].setWayState(Maze_Constant.WAY_SOUTH, Maze_Constant.WAY_DISABLE);
				mazeNodes[xPos+1][yPos].setWayState(Maze_Constant.WAY_NORTH, Maze_Constant.WAY_DISABLE); 
			}else if(top.getWayState(Maze_Constant.WAY_WEST)) {
    
    
				//西
				stack.push(mazeNodes[xPos][yPos-1]);
				
				mazeNodes[xPos][yPos].setWayState(Maze_Constant.WAY_WEST, Maze_Constant.WAY_DISABLE);
				mazeNodes[xPos][yPos-1].setWayState(Maze_Constant.WAY_EAST, Maze_Constant.WAY_DISABLE);
			}else if(top.getWayState(Maze_Constant.WAY_NORTH)) {
    
    
				//北
				stack.push(mazeNodes[xPos-1][yPos]);
				
				mazeNodes[xPos][yPos].setWayState(Maze_Constant.WAY_NORTH, Maze_Constant.WAY_DISABLE);
				mazeNodes[xPos-1][yPos].setWayState(Maze_Constant.WAY_SOUTH, Maze_Constant.WAY_DISABLE);
			}else if(!top.getWayState(Maze_Constant.WAY_EAST)&&!top.getWayState(Maze_Constant.WAY_WEST)&&!top.getWayState(Maze_Constant.WAY_NORTH)&&!top.getWayState(Maze_Constant.WAY_SOUTH)) {
    
    
				//说明进入死胡同结点（四周都不能走），从栈中删除栈顶元素，重找
				stack.pop();//删除栈顶元素
				
			}
		}
		
		show();
	}

	//找到路径后，需要将栈中的元素值改为可识别的
	private void show() {
    
    
		// TODO Auto-generated method stub
		if(stack.isEmpty()) {
    
    
			System.out.println("没有迷宫路径");
			return;//退出
		}
		
		while(!stack.isEmpty()) {
    
    
			MazeNode top=stack.peek();
			top.setValue(8);
			stack.pop();
		}
		System.out.println("路径已找到，如下(2代表行走 的路径)：");
		for(int i=0;i<row;i++) {
    
    
			   for(int j=0;j<column;j++){
    
    
				   System.out.print(mazeNodes[i][j].getValue()+" ");
			   }
			   System.out.println();
		}
	}
}

Maze_Constant.java

public class Maze_Constant {
    
    
	public static final int WAYSIZE=4;
	public static final int WAY_EAST=0;//东南西北
	public static final int WAY_SOUTH=1 ;
	public static final int WAY_WEST=2 ;
	public static final int WAY_NORTH=3 ;
	
	public static final boolean WAY_ABLE=true ;
	public static final boolean WAY_DISABLE=false ;
	
}

MazeNode.java

public class MazeNode {
    
    
	private int value;//0或1
	//当前对象在二维数组中的位置
	private int xPos;//行
	private int yPos;//列
	private boolean[]  WayState;//4个元素代表4个方向
	
	public MazeNode(int value, int xPos, int yPos) {
    
    
		WayState =new boolean[Maze_Constant.WAYSIZE];
		this.value = value;
		this.xPos = xPos;
		this.yPos = yPos;
	}

	public int getValue() {
    
    
		// TODO Auto-generated method stub
		return value;
	}

	public void setWayState(int direction, boolean isAble) {
    
    
		// TODO Auto-generated method stub
		this.WayState[direction]=isAble; 
	}

	
	
	public int getxPos() {
    
    
		return xPos;
	}


	public int getyPos() {
    
    
		return yPos;
	}
	
	
	
	public boolean getWayState(int direction) {
    
    
		// TODO Auto-generated method stub
		return WayState[direction];
	}

	
	public void setValue(int i) {
    
    
		// TODO Auto-generated method stub
		value=i;
	}
	
	
}

MazeTest.java

import java.util.Scanner;
import javax.xml.soap.SAAJResult;

public class MazeTest {
    
    

	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
		System.out.println("请输入行列数");
		Scanner sc=new Scanner(System.in);
		int row =sc.nextInt();
		int column=sc.nextInt();
		Maze maze=new Maze(row,column);
		maze.goMaze();
	}

}

Enlaces relacionados:

Diseño de realización de proyectos de rompecabezas