Realização do projeto de labirinto

Introdução ao projeto:

 Um labirinto de grade consiste em n linhas em colunas de células, e cada composto é uma clareira (representado por 0) ou um obstáculo (representado por 1). Sua tarefa é encontrar uma sequência móvel do ponto inicial ao ponto final, que só pode se mover para cima, para baixo, para a esquerda e para a direita até as células adjacentes. Em nenhum momento você pode estar em uma cela com obstáculos, nem pode sair do labirinto. O ponto inicial é o canto superior esquerdo e o ponto final no canto inferior direito.

Função do projeto:

1. Encontre um caminho válido desde a entrada do labirinto no canto superior esquerdo até a saída do labirinto no canto inferior direito .
2. 0 significa que pode ser percorrido a pé, 1 significa incapaz de caminhar e 8 significa caminho percorrido.
3. Se você encontrá-lo, envie as informações finais do labirinto e do caminho. Se você encontrar, indique que não há um caminho válido.

Pontos de conhecimento do projeto:

 Implementado usando ideias orientadas a objetos Java, matrizes bidimensionais e pilhas não recursivas

Ideia do projeto:

1. Defina uma matriz bidimensional do tipo de nó do labirinto (MazeNode)
2. Inicialize o valor em cada grade. Armazene objetos para cada grade de uma matriz bidimensional. O valor do objeto só pode ser 0 (a grade atual pode ser movida) ou 1 (a grade atual não pode ser movida)
3. Inicialize se as quatro direções (sudeste, noroeste) de cada grade podem ser percorridas. De acordo com os valores dos valores nas grades nas quatro direções ao redor do nó atual, julgue se as quatro direções do nó atual podem ser percorridas (0 é para ir, 1 é para ir).
4. Comece a caminhar pelo labirinto. Use a operação de pilha para registrar o caminho de caminhada, empurre o elemento superior esquerdo na pilha, julgue em qual direção o elemento superior da pilha atual pode ir e empurre uma das direções possíveis na pilha até que o elemento inferior direito pare. O caminho percorrido é salvo na pilha.
   Nota: Se você encontrar o problema de entrar em um beco sem saída, você precisa ser o elemento do topo da pilha neste momento e o elemento do topo da pilha não pode caminhar nas quatro direções. Neste momento, retire-o da empilhar e escolher uma nova direção para empurrá-lo de volta para a pilha até que o elemento no canto inferior direito pare.

Dados de teste e análise:

1. Vá direto

2. Precisa voltar e encontrar uma nova maneira

3. Em lugar nenhum, volte até que a pilha esteja vazia

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();
	}

}

Links Relacionados:

Design de realização de projeto de quebra-cabeça