Java迷宫回溯

Question

我目前正在尝试为java做迷宫回溯，这是在学校里，我不能使用ArrayLists，所以我必须创建自己的列表，问题是每次在主类上崩溃的程序，似乎就像它指向null并崩溃一样。主类我创建矩阵并读取它，现在我实际上是在做程序的基础，然后我将添加诸如每个位置的点之类的复杂内容。我认为这是主类的问题，它由于以下原因而崩溃变量aux ，但我不知道如何解决。

主类：

    import java.io.File;
import java.io.FileNotFoundException;
import java.lang.invoke.CallSite;
import java.util.Scanner;

public class Principal {

    public static void main(String[] args) throws FileNotFoundException {
        String[] linies = llegirLiniesFitxer(6);

        int c = 1;

        String[] linea1 = linies[0].split(", ");


        int files = Integer.parseInt(linea1[0]);
        int columna = Integer.parseInt(linea1[1]);
        int filaEntrada = Integer.parseInt(linea1[2]);
        int columnaEntrada = Integer.parseInt(linea1[3]);
        int filaSortida = Integer.parseInt(linea1[4]);
        int columnaSortida = Integer.parseInt(linea1[5]);
        int valor;

        String[][] matriu = new String[files][columna];
        String[][] copiaMat = matriu.clone();
        Casella[][] mapaCaselles = new Casella[files][columna];

        boolean esBloque = false;
        boolean esFi = false;

        for(int g = 0; g<files;g++) {
            String[] elements = linies[c].split(", ");
            if(c<5) c++;
            for(int h = 0; h<columna;h++)   {

                matriu[g][h] = elements[h]; 
            }
        }

        int puntuacioInicial = Integer.parseInt(matriu[filaEntrada][columnaEntrada]);

        for(int i = 0; i<files;i++) {
            for(int j = 0;j<columna;j++) {
                int op = retornaOperacio(copiaMat, i,j);
                if(copiaMat[i][j].contains("N")) {
                    esBloque = true;
                }

                if(i == filaSortida && j == columnaSortida) {
                    esFi = true;
                }
                valor = obtenirValor(matriu[i][j]);

                boolean dir1 = esVisitable(i, j+1, matriu, files, columna); // Columna + 1
                boolean dir2 = esVisitable(i, j-1, matriu, files, columna); // Columna - 1
                boolean dir3 = esVisitable(i+1, j, matriu, files, columna); // Fila + 1
                boolean dir4 = esVisitable(i-1, j, matriu, files, columna); // Fila - 1

                mapaCaselles[i][j] = new Casella(i,j,op,valor, esBloque, new boolean[]{dir1,dir2,dir3,dir4}, esFi);
                esBloque = false;
                esFi = false;
            }
        }


        LlistaCamins cami = new LlistaCamins(10000);
        Laberint laberint = new Laberint(mapaCaselles);
        cami.afegirCami(mapaCaselles[filaEntrada][columnaEntrada]);

        omplirCamins(laberint, mapaCaselles[0][0], cami);

        laberint.escriureCamins();

}

    public static void omplirCamins(Laberint laberint, Casella casellaActual, LlistaCamins cami) {
        if(casellaActual.isFi()) {
            laberint.afegirCami(cami.copia());
        } else {
            int[][] moviments = {
                    {-1, 0}, //arriba
                    {0, 1}, // derecha
                    {1, 0}, // abajo
                    {0, -1} // izquierda
                };

            int posXnova;
            int posYnova;
            Casella aux;

            for(int i = 0;i<moviments.length;i++) {
                posXnova = casellaActual.getX() + moviments[i][0];
                posYnova = casellaActual.getX() + moviments[i][1];
                aux = laberint.getCasellaAt(posXnova, posYnova);
                System.out.println("Mida aux" + aux);
                switch(i) {
                    case 0:
                        if(laberint.adaltDisponible(casellaActual, aux)) {
                            cami.afegirCami(aux);
                            casellaActual.setVisitada(true);
                            omplirCamins(laberint, aux, cami);
                            casellaActual.setVisitada(true);
                            cami.eliminarCami(aux);
                        }
                        break;
                    case 1:
                        if(laberint.dretaDisponible(casellaActual, aux)) {
                            cami.afegirCami(aux);
                            casellaActual.setVisitada(true);
                            omplirCamins(laberint, aux, cami);
                            casellaActual.setVisitada(true);
                            cami.eliminarCami(aux);
                        }
                        break;
                    case 2:
                        if(laberint.abaixDisponible(casellaActual, aux)) {
                            cami.afegirCami(aux);
                            casellaActual.setVisitada(true);
                            omplirCamins(laberint, aux, cami);
                            casellaActual.setVisitada(true);
                            cami.eliminarCami(aux);
                        }
                        break;
                    case 3:
                        if(laberint.esquerraDisponible(casellaActual, aux)) {
                            cami.afegirCami(aux);
                            casellaActual.setVisitada(true);
                            omplirCamins(laberint, aux, cami);
                            casellaActual.setVisitada(true);
                            cami.eliminarCami(aux);
                        }
                        break;
                }
            }
        }
    }

    private static boolean esVisitable(int x, int y, String[][] taula, int files, int col) {
        if(x < 0 || y < 0) return false;    
        if(x >= files || y >= col) return false;
        if(taula[x][y].equalsIgnoreCase("NA") || taula[x][y] == null) return false;
        return true;
    }

    private static int retornaOperacio(String[][] mat, int f,int c) {

        /*
         * 0 -> SUMA
         * 1 -> RESTA
         * 2 -> DIVISIO
         * 3 -> MULTIPLIACIO
         */
        if(mat[f][c].startsWith("+")) return 1;
        if(mat[f][c].startsWith("-")) return 0;
        if(mat[f][c].startsWith("*")) return 3;
        if(mat[f][c].startsWith("/")) return 2;
        return -1;
    }

    private static int obtenirValor(String valor) {

        if(valor.startsWith("N")) {
            return 999;
        }
        String[] separar = valor.split("");
        int v = Integer.parseInt(separar[1]);
        return v;
    }

    private static String[] llegirLiniesFitxer(int numLin) throws FileNotFoundException {
        String[] result;
        if (numLin<0) numLin=0;
        result=new String[numLin];
        Scanner f=new Scanner(new File("Laberints.txt"));

        for (int i=0; i<numLin; i++) {
            result[i]=f.nextLine();
        }
        f.close();
        return result;
    }

    private static void imprimirMatriu(String[][] mat, int fila, int col) {
        for(int i =0;i<fila;i++) {
            for(int j=0;j<col;j++) {
                System.out.print(mat[i][j] + " ");
            }
            System.out.println();
        }
    }
}

位置等级

公共课程Casella {

private int x;
private int y;
private int operacio;
private int valor;
private boolean esBloque;
private boolean visitada;
private boolean[] direccions;
private boolean fi;

public Casella(int x, int y, int operacio, int valor, boolean esBloque, boolean[] direccions, boolean fi) {
    this.setX(x);
    this.setY(y);
    this.setEsBloque(esBloque);
    this.setVisitada(false);
    this.setOperacio(operacio);
    this.setValor(valor);
    this.direccions = direccions;
    this.setFi(fi);
}


public int getX() {
    return x;
}

public void setX(int x) {
    this.x = x;
}

public int getOperacio() {
    return operacio;
}

public void setOperacio(int operacio) {
    this.operacio = operacio;
}

public int getValor() {
    return valor;
}

public void setValor(int valor) {
    this.valor = valor;
}

public int getY() {
    return y;
}

public String toString() {
    return ("(X:"+x+ "Y:"+y+")");
}

public boolean adaltDisponible() {
    return direccions[0];
}

public boolean dretaDisponible() {
    return direccions[1];
}

public boolean abaixDisponible() {
    return direccions[2];
}

public boolean esquerraDisponible() {
    return direccions[3];
}

public void setY(int y) {
    this.y = y;
}

public boolean isEsBloque() {
    return esBloque;
}

public void setEsBloque(boolean esBloque) {
    this.esBloque = esBloque;
}

public boolean isVisitada() {
    return visitada;
}

public void setVisitada(boolean visitada) {
    this.visitada = visitada;
}

public Casella copia() {
    return new Casella(x, y, operacio, valor, esBloque, direccions, fi);
}

public boolean isFi() {
    return fi;
}

public void setFi(boolean fi) {
    this.fi = fi;
}

}

迷宫课

公共类Laberint {

private Casella[][] tauler;
private LlistaLlistaCamins camins;

public Laberint(Casella[][] tauler) {
    this.tauler = tauler;
    camins = new LlistaLlistaCamins(10000);
}

public boolean adaltDisponible(Casella casilla, Casella desti) {
    if(!desti.isVisitada() && desti != null) {
        return casilla.adaltDisponible();
    }
    return false;
}

public boolean dretaDisponible(Casella casilla, Casella desti) {
    if(!desti.isVisitada() && desti != null) {
        return casilla.dretaDisponible();
    }
    return false;
}

public boolean abaixDisponible(Casella casilla, Casella desti) {
    if(!desti.isVisitada() && desti != null) {
        return casilla.abaixDisponible();
    }
    return false;
}

public boolean esquerraDisponible(Casella casilla, Casella desti) {
    if(!desti.isVisitada() && (desti != null)) {
        return casilla.esquerraDisponible();
    }
    return false;
}

public Casella getCasellaAt(int x, int y) {
    if(dinsLimit(x,y)) {
        return tauler[x][y];
    }
    return null;
}

public boolean dinsLimit(int x, int y) {
    return ((x>=0 && x < tauler.length) && (y>=0 && y<tauler[0].length));
}

public void escriureCamins() {
    for(int i = 0; i<camins.getnElem();i++) {
        camins.mostrarCamins();
    }
}

public void afegirCami(LlistaCamins cami) {
    if(cami != null) {
        camins.afegirCamins(cami);
    }
}

}