java - キューを使用した幅探索の最初の迷路ソルバー

Question

迷路を解くために、キューを使用して幅優先探索に従うプログラムを作成する必要があります。ほぼ完了したと思いますが、実行すると、メインタイプが含まれていないと表示されます。また、47 行目と 48 行目のコード (i = current.i および j=current.j) の何が問題なのか説明してもらえますか?フィールドではありませんが、while ループの上で宣言することは問題ありません. それも重要ではありませんが、私の先生は repaint() メソッドを使用して、迷路が自分で解決するのを見ることができるようにするように求めました. どうすればよいかわかりませんこの方法を使用しますが、そのコードも含めました.このプログラムを実行するための助けがあれば大歓迎です.

import java.awt.Point;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;

public class MazeSolver {
public static final int WALL = 1, OPEN = 0, GOAL = 2, START = 3;
public static final int ACTIVE = 4, SOLUTION = 5;
    private int[][] maze = {
        {1, 1, 1, 1, 1, 1, 1, 1},
        {1, 3, 0, 0, 0, 0, 0, 1},
        {1, 1, 0, 1, 1, 1, 0, 1},
        {1, 1, 0, 1, 0, 1, 0, 1},
        {1, 0, 0, 0, 0, 1, 0, 1},
        {1, 1, 0, 1, 1, 1, 0, 1},
        {1, 0, 0, 0, 0, 1, 2, 1},
        {1, 1, 1, 1, 1, 1, 1, 1},
    };

public static Point startSearch(int[][] grid) {
    int x = -1, y = -1;
    for (int col = 0; col < grid.length; col++) {
        for (int row = 0; row < grid.length; row++) {
            if (grid[col][row] == 3) {
                x = col;
                y = row;
                return new Point(x, y);
            }
        }
    }
    return null;
}

public static Point[] algorithm(int[][] maze) {
    ConcurrentLinkedQueue<Point> path = new ConcurrentLinkedQueue<Point>();
    ConcurrentLinkedQueue<Point> predecessor = new ConcurrentLinkedQueue<Point>();

    Point start = startSearch(maze);
    Point current;
    Point north, south, east, west;

    int i = 0;
    int j = 0;
    path.offer(start);
    while (!path.isEmpty()) {
        current = path.poll();
        i = current.i;
        j = current.j;
        if (i == maze.length - 1 && j == maze.length - 1
                && maze[i][j] == '0') {
            Point[] trail = new Point[path.size()];
            while (path.isEmpty()) {
                for (int k = 0; k < path.size(); k++) {
                    trail[k] = path.poll();
                } return trail;
            }
        }

        east = new Point(i, j + 1);
        south = new Point(i + 1, j);
        west = new Point(i, j - 1);
        north = new Point(i - 1, j);
        if (j + 1 >= 0 && j + 1 < maze.length && maze[i][j + 1] == '0'
                && predecessor.contains(east) == false) {
            predecessor.offer(east);
            path.offer(current);
            path.offer(east);
        } else if (i + 1 >= 0 && i + 1 < maze.length
                && maze[i + 1][j] == '0'
                && predecessor.contains(south) == false) {
            predecessor.offer(south);
            path.offer(current);
            path.offer(south);
        } else if (j - 1 >= 0 && j - 1 < maze.length
                && maze[i][j - 1] == '0'
                && predecessor.contains(west) == false) {
            predecessor.offer(west);
            path.offer(current);
            path.offer(west);
        } else if (i - 1 >= 0 && i - 1 < maze.length
                && maze[i - 1][j] == '0'
                && predecessor.contains(north) == false) {
            predecessor.offer(north);
            path.offer(current);
            path.offer(north);
        }

    }

    return null;
}

public int[][] getMaze() {
    return maze;
}

public static void main(String args) {
    new MazeSolver();
}

repaint() に使用するメソッドは次のとおりです。この部分は重要ではありませんが、どのように機能するかについてのヘルプまたは説明があれば幸いです。

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import javax.swing.JComponent;

public class MazeViewer extends JComponent {
    private static final long serialVersionUID = 1L;
    private final MazeSolver parent;
    public MazeViewer(MazeSolver parent) {
        this.parent = parent;
        setPreferredSize(new Dimension(500, 500));
    }
    @Override
    public void paintComponent(Graphics graphics) {
        int[][] maze = parent.getMaze();
        int cellSize = Math.min(getWidth() / maze[0].length, getHeight()
                / maze.length);
        graphics.setColor(Color.GRAY);
        graphics.fillRect(0, 0, getWidth(), getHeight());

        for (int row = 0; row < maze.length; row++)
            for (int col = 0; col < maze[0].length; col++)
                drawCell(graphics, maze[row][col], row, col, cellSize);
    }
    private void drawCell(Graphics graphics, int mazeCellValue, int row,
            int col, int cellSize) {
        switch (mazeCellValue) {
        case MazeSolver.WALL:
            graphics.setColor(Color.BLACK);
            break;
        case MazeSolver.OPEN:
            graphics.setColor(Color.WHITE);
            break;
        case MazeSolver.GOAL:
            graphics.setColor(Color.RED);
            break;
        case MazeSolver.START:
            graphics.setColor(Color.GREEN);
            break;
        case MazeSolver.ACTIVE:
            graphics.setColor(Color.CYAN);
            break;
        case MazeSolver.SOLUTION:
            graphics.setColor(Color.GREEN);
            break;
        }
        graphics.fillRect(col * cellSize, row * cellSize, cellSize,
                cellSize);
        graphics.setColor(Color.GRAY); // border
        graphics.drawRect(col * cellSize, row * cellSize, cellSize,
                cellSize);
    }
}