使用队列广度搜索第一个迷宫求解器

Question

I have to write a program that follows a breadth first search using queues to solve a maze. I think I almost have it done but when I run it, it says it does not contain a main type. Also can some one explain to me what is wrong with the code on line 47 and 48 (i = current.i and j=current.j) it should be fine but i get an error message that says it "cannot be resolved or is not in field, i though declaring above the while loop would be fine. It is also not critical but me teacher asked for us to use a repaint() method so we can see the maze solve itself. I'm not really sure how to use thus method but I have included that code as well. Any help to get this program running would be greatly appreciated.

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

and here is the method we are supposed to use for repaint(), this part isn't crucial but some help or an explanation of how it works would be great.

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

Answer 1

I think the reason your program cannot be run because you've declared your main function as this

public static void main(String args) 

but it actually should have an array of Strings as the argument. ie. this

public static void main(String[] args)