On m'a confié la tâche de créer un solutionneur de labyrinthe en Java. Voici la mission:
Write an application that finds a path through a maze.
The maze should be read from a file. A sample maze is shown below.
O O O O O X O
X X O X O O X
O X O O X X X
X X X O O X O
X X X X O O X
O O O O O O O
X X O X X X O
Le caractère "X" représente un mur ou une position bloquée et le caractère "O" représente une position ouverte. Vous pouvez supposer que l'entrée du labyrinthe se trouve toujours dans le coin inférieur droit et que la sortie se trouve toujours dans le coin supérieur gauche. Votre programme doit envoyer sa sortie dans un fichier. Si un chemin est trouvé, le fichier de sortie doit contenir le chemin. Si aucun chemin n'est trouvé, un message doit être envoyé au fichier. Veuillez noter qu'un labyrinthe peut avoir plusieurs solutions, mais dans cet exercice, il vous est uniquement demandé de localiser une solution, pas toutes les solutions.
Votre programme doit utiliser une pile pour enregistrer le chemin qu'il explore et revenir en arrière lorsqu'il atteint une position bloquée.
Assurez-vous d'écrire un algorithme complet avant d'écrire votre code. N'hésitez pas à créer des classes supplémentaires qui vous aideront à mener à bien la tâche.
Here's my Algorithm:
1)Initialize array list to hold maze
2)Read text file holding maze in format
o x x x x o
o o x o x x
o o o o o x
x x x x o o
3)Create variables to hold numbers of columns and rows
3)While text file has next line
A. Read next line
B. Tokenize line
C. Create a temporary ArrayList
D. While there are tokens
i. Get token
ii. create a Point
iii. add point to temp ArrayList
iv. increment maximum number of columns
E. Add temp to maze arraylist, increment max rows
F. initialize a hold of points as max rows - 1
G. Create a start point with x values as maximum number of rows - 1, and y values as maximum number of columns - 1
H. Create stack of points and Push starting location
I. While finished searching is not done
i. Look at top of stack and check for finish
ii. check neighbors
iii. is there an open neighbor?
- if yes, update flags and Push
- if no, pop from stack
J. Print solution
4. Done is true
Quoi qu’il en soit, ce que j’ai mis en place est une classe de points qui a défini/obtenu des méthodes pour voyager dans toutes les directions cardinales et qui retournera des booléens comme indiqué:
public class Points<E>
{
private int xCoord;
private int yCoord;
private char val;
private boolean N;
private boolean S;
private boolean E;
private boolean W;
public Points()
{
xCoord =0;
yCoord =0;
val =' ';
N = true;
S = true;
E = true;
W = true;
}
public Points (int X, int Y)
{
xCoord = X;
yCoord = Y;
}
public void setX(int x)
{
xCoord = x;
}
public void setY(int y)
{
yCoordinate = y;
}
public void setNorth(boolean n)
{
N = n;
}
public void setSouth(boolean s)
{
S= s;
}
public void setEast(boolean e)
{
E = e;
}
public void setWest(boolean w)
{
W = w;
}
public int getX()
{
return xCoord;
}
public int getY()
{
return yCoord;
}
public char getVal()
{
return val;
}
public boolean getNorth()
{
return N;
}
public boolean getSouth()
{
return S;
}
public boolean getEast()
{
return E;
}
public boolean getWest()
{
return W;
}
public String toString1()
{
String result = "(" + xCoord + ", " +yCoord + ")";
return result;
}
}
J'ai simplement du mal à obtenir la résolution réelle dans son ensemble. Voici ce que j'ai
import Java.io.*;
import Java.util.*;
import Java.lang.*;
import Java.text.*;
public class MazeSolve1
{
public static void main(String[] args)
{
//Create arrayList of Points
ArrayList<ArrayList<Points>> MAZE = new ArrayList<ArrayList<Points>>();
Scanner in = new Scanner(System.in);
//Read File in
System.out.print("Enter the file name: ");
String fileName = in.nextLine();
fileName = fileName.trim();
FileReader reader = new FileReader(fileName+".txt");
Scanner in2 = new Scanner(reader);
//Write file out
FileWriter writer = new FileWriter("Numbers.out");
PrintWriter out = new PrintWriter(writer);
boolean done = false;
int maxCol = 0;
int maxRow = 0;
while(!done) {
//creating array lists
while (in2.hasNextLine()) {
//Read next line
String nextLine = in2.nextLine();
//Tokenize Line
StringTokenizer st = new StringTokenizer(nextLine, " ");
//Create temp ArrayList
ArrayList<ArrayList<Points>> temp = new ArrayList<ArrayList<Points>>();
//While there are more tokens
while (st.hasNextToken()) {
String token = st.nextToken();
Points pt = new Points();
temp.add(pt);
maxCol++
}
MAZE.add(temp);
maxRow++;
}
//create hold arraylist for max rows of maze -1
//create variables for start x and y coordinates
ArrayList<ArrayList<Points>> hold = new ArrayList<ArrayList<Points>>();
hold = MAZE.get(maxRow - 1);
int startColumn = hold.get(maxCol - 1);
int startRow = hold.get(maxRow - 1);
Point start = new Point();
start.setX(startColumn);
start.setY(startRow);
//initialize stack, and Push the start position
MyStack<Points> st = new ArrayStack<Points>();
st.Push(start.toString1());
//south and east of start are edges of array
start.setSouth(false);
start.setEast(false);
//while your position is not equal to point (0,0) [finish]
while (st.peek() != "(0, 0)") {
//getting the next coordinate to the North
int nextY = start.getY() - 1;
int nextX = start.getX();
//if character to the North is an O it's open and the North flag is true
if (hold.get(nextY) = 'O' && start.getNorth() == true) {
//set flags and Push coordinate
start.setNorth(false);
st.Push(start.toString1());
}
//else pop from stack
else { st.pop(); }
//look at coordinate to the East
nextX = start.getX() + 1;
//if character to the East is a O and the East flag is true
if (hold.get(nextX) = 'O' && start.getEast() == true) {
//set flags and Push coordinate
start.setEast(false);
st.Push(start.toString1());
}
//else pop from stack
else { st.pop(); }
//look at coordinate to the South
nextY = start.getY() + 1;
//if character to the South is a O and the West flag is true
if (hold.get(nextY) = 'O' && start.getSouth() == true) {
//set flags and Push coordinate
start.setSouth(false);
st.Push(start.toString1());
}
//else pop from stack
else { st.pop() }
//keep looping until the top of the stack reads (0, 0)
}
done = true;
}
//Print the results
System.out.println("---Path taken---");
for (int i = 0; i< st.size(); i++) {
System.out.println(st.pop);
i++
}
Mis à part les erreurs de syntaxe, pourriez-vous me proposer de l'aide? Merci beaucoup.
J'ai soumis une réponse similaire ici Algorithme de résolution de labyrinthe en C++ .
Pour avoir une chance de le résoudre, vous devez:
Solve()
et appelez-la récursivement: Solve
a réussi à trouver une solutionVoici un pseudo-code pour la solution.
boolean solve(int X, int Y)
{
if (mazeSolved(X, Y))
{
return true;
}
// Test for (X + 1, Y)
if (canMove(X + 1, Y))
{
placeDude(X + 1, Y);
if (solve(X + 1, Y)) return true;
eraseDude(X + 1, Y);
}
// Repeat Test for (X - 1, Y), (X, Y - 1) and (X, Y + 1)
// ...
// Otherwise force a back track.
return false;
}
Vous devriez probablement module votre programme - si je comprends bien, vous lisez le labyrinthe à partir d’un fichier et essayez de le résoudre en même temps.
Une meilleure approche serait de scinder le programme en 2 parties distinctes:
Cela vous aidera à construire et à tester chaque pièce séparément, ce qui aboutira probablement à un programme meilleur et plus fiable.
Pour résoudre le labyrinthe, vous pouvez utiliser un simple BFS , similaire à ce que votre algorithme avait suggéré à l’origine, à savoir un DFS
Comme Amit l’a dit, vous devez d’abord lire le labyrinthe en entier et le stocker dans un tableau à 2 dimensions. Cela vous permet de voir tout le labyrinthe sans avoir à le résoudre ligne par ligne.
Comme vous devez d’abord trouver la taille du tableau, vous devez lire le fichier texte dans une liste de chaînes.
List<String> strs = new ArrayList<String>();
//Pseudocode, choose however you want to read the file
while(file_has_next_line) {
strs.add(get_next_line);
}
La taille de la liste vous donne le nombre de lignes, et en supposant que c'est toujours une grille, vous pouvez utiliser split (). Length, (compter les espaces + 1) ou compter les symboles sur l'une des chaînes pour obtenir le nombre de colonnes. .
Le moyen le plus simple de stocker les données cartographiques consiste à utiliser un tableau 2D de booléens. Où vrai est un mur et faux est un espace vide.
boolean[][] wallMap = new boolean[rows][cols];
for(int i = 0; i < wallMap.length; i++) {
//Separate each symbol in corresponding line
String[] rowSymbols = strs.get(i).split(" ");
for(int j = 0; j < wallMap[i].length; j++) {
//Ternary operator can be used here, I'm just keeping it simple
if(rowSymbols[j].equals("X")) {
wallMap[i][j] = true;
} else {
wallMap[i][j] = false;
}
}
}
Maintenant que les données de la carte sont stockées dans un tableau, il est beaucoup plus facile de parcourir la carte et de faire vos choix. Vous pouvez utiliser un algorithme prêt à l'emploi (voir la réponse de amit) ou créer le vôtre. Comme ce sont des devoirs, vous devriez essayer de penser aux vôtres.
S'amuser.
J'ai essayé d'implémenter cela en utilisant l'algorithme DFS en utilisant certains concepts Java OOP.
Voir la solution complète sur mon dépôt github
private boolean solveDfs() {
Block block = stack.peekFirst();
if (block == null) {
// stack empty and not reached the finish yet; no solution
return false;
} else if (block.equals(maze.getEnd())) {
// reached finish, exit the program
return true;
} else {
Block next = maze.getNextAisle(block);
// System.out.println("next:" + next);
if (next == null) {
// Dead end, chose alternate path
Block discard = stack.pop();
discard.setInPath(false);
// System.out.println("Popped:" + discard);
} else {
// Traverse next block
next.setVisited(true);
next.setInPath(true);
stack.Push(next);
}
}
return solveDfs();
}
Vous devez séparer votre programme en deux phases. Le premier est l'initialisation, où vous lisez la description du labyrinthe et la position initiale du joueur. Après cela, vous avez une structure de données pour représenter le tableau. Le second est le jeu actuel, où il devrait y avoir 3 abstractions:
Chacun de ceux-ci devrait pouvoir changer sans trop changer les autres. Par exemple, vous pouvez être invité à améliorer votre algorithme de recherche ou à résoudre un problème pour lequel vous avez plusieurs objectifs. La facilité avec laquelle on passe du problème actuel à un problème légèrement modifié constitue la véritable mesure de la conception d’un programme.