web-dev-qa-db-fra.com

Création d'un algorithme de résolution de labyrinthe en Java

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.

javaalgorithmmaze
7
Copernikush

enter image description here

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:

  • Créez une routine Solve() et appelez-la récursivement:
    • si 1st, 2nd, 3rd, ... are true Solve a réussi à trouver une solution
    • si 1st, 2nd, 3rd, ... contient un faux, il doit revenir en arrière et trouver un autre moyen
  • Vous devez créer un tampon des endroits que vous avez visités pour éviter les boucles infinies
    • pendant que vous faites des mouvements, il doit garder un œil dessus
    • quand nous arrivons dans une impasse, nous devons effacer les mauvais mouvements
    • nous pouvons mettre en œuvre ce qui précède en brûlant une supposition et en l'enlevant s'il est faux

Voici 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;
 }
13
Stephen Quan

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:

  1. lire le fichier d'entrée et créer une matrice avec toutes les données
  2. résoudre le labyrinthe de la matrice donnée

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

7
amit

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.

1
Hedja

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

}

0
Narain Mittal

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:

  • L'état du joueur. Dans votre cas, c'est assez simple, sa position réelle sur le tableau.
  • Le labyrinthe lui-même, qui est l'environnement. Il devrait avoir des fonctions vous indiquant si vous avez visité une position donnée, marquer la position que vous avez visitée, où se trouve l'objectif, les prochaines cellules accessibles, etc.
  • La logique, qui est l'algorithme de recherche.

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.

0
UmNyobe