So my project was to make an algorithm that finds a path out the maze using backtracking to help. This is my first time attempting to solve anything with backtracking so I want to be sure if what I did is actually backtracking and if it is an efficient way to apply it to my problem. Bellow is the main logic:public void solve(Cell cell){    tempMaze[cell.getRow()][cell.getColumn()] = !;    ArrayList<Cell> neighbors = getNeighbors(cell);    // If cell is at edge of board a solution is found    if ((cell.getRow() == 0 || cell.getRow() == tempMaze.length-1) || (cell.getColumn() == 0 || cell.getColumn() == tempMaze[0].length-1)){        return;    }    // If cell is in initial position and has no neighbors then quit    if ((cell.getColumn() == initColPosition && cell.getRow() == initRowPosition) && neighbors.size() < 1){        return;    }    // If not in initial position and has no neighbors then backtrack    if ((cell.getColumn() != initColPosition || cell.getRow() != initRowPosition) && neighbors.size() < 1){        result.remove(result.size()-1);        solve(result.get(result.size()-1));    }else if (neighbors.size() >= 1){ // If has neighbors then choose one and call the method again        result.add(neighbors.get(0));        solve(neighbors.get(0));    }}This is the results array were I keep all the cells that make up the solution to the maze: ArrayList<Cell> result = new ArrayList<Cell>();This is where, in theory, my backtracking kicks in: solve(result.get(result.size()-1)); So, for example lets say I moved x amount of times and my result contains the following cells: a,b,c,d,e. Because e happened to be a good cell to move to I moved to it, however when I recursively call solve(e) to check further possible moves there are no more neighbors to move to. Because of this I backtrack. So if this would happen my code would delete e from the result array and call solve(Cell cell) with the cell before e. So now my result array looks as follows: a,b,c,d and solve was recursively called with d like this: solve(d). Lets pretend that d also does not have anymore locations to move to, if this happens same process occurs as with e. Now my array looks as follows if d also did not have another valid location, or Cell, to move to: a,b,c. This time I call solve(Cell cell) with c and pretend that it has a location to move to that is different from d. If this happens I move to that Cell and add it to my result array. This process keeps going until one of my base cases is reached. So is the way I move to previous moves and look for other solutions backtracking or not? Why is it not considered backtracking if my approach is incorrect? If it is correct did I do this in an acceptable manner? If not why? I would greatly accept your opinions and suggestions.The rest of my class (without solve() method): public class ThreadTheMaze {    ArrayList<Cell> result = new ArrayList<Cell>();    private String[][] maze;    private String[][] tempMaze;    private int initRowPosition;    private int initColPosition;    private int amtOfRows;    private int amtOfCols;    public ThreadTheMaze(int initRow, int initCol){        initRowPosition = initRow;        initColPosition = initCol;        result.add(new Cell(initRowPosition, initColPosition));    }    public void loadMaze(){        try{            Scanner in = new Scanner(new File(mazeData.txt));            while (in.hasNextLine()){                amtOfCols = in.nextLine().length();                amtOfRows++;            }            in.close();            maze = new String[amtOfRows][amtOfCols];            in = new Scanner(new File(mazeData.txt));            for (int r = 0; r < amtOfRows; r++){                String line = in.nextLine();                for (int c = 0; c < amtOfCols; c++){                    maze[r][c] = line.substring(0,1);                    line = line.substring(1);                }            }            tempMaze = new String[maze.length][];            for (int r = 0; r < tempMaze.length; r++){                tempMaze[r] = maze[r].clone();            }        }catch (FileNotFoundException e){            System.err.print(e);        }    }    public void printMaze(){        for (int r = 0; r < amtOfRows; r++){            for (int c = 0; c < amtOfCols; c++){                System.out.print(maze[r][c]);            }            System.out.println();        }    }    public void updateMaze(){        for (int i = 0; i < result.size(); i++){            maze[result.get(i).getRow()][result.get(i).getColumn()] = !;        }    }    /**     @return ArrayList of objects 'Cell' that are empty and available to move to.    */    private ArrayList<Cell> getNeighbors(Cell cell){        ArrayList<Cell> neighbors = new ArrayList<Cell>();        int row = cell.getRow();        int column = cell.getColumn();        int[][] moveLocs = {{row-1, column}, {row+1, column}, {row, column+1}, {row, column-1}};        for (int r = 0; r < moveLocs.length; r++){            int tRow = moveLocs[r][0];            int tCol = moveLocs[r][1];            if (isValid(tRow, tCol)){                Cell neighbor = new Cell(tRow, tCol);                neighbors.add(neighbor);            }        }        return neighbors;    }    public boolean isValid(int row, int col){        if(row < 0 || row >= amtOfRows){            return false;        }        if (col < 0 || col >= amtOfCols){            return false;        }        if (!tempMaze[row][col].equals( )){            return false;        }        return true;    }}UPDATE: Main: public class Main {    public static void main(String args[]) throws IOException{        ThreadTheMaze x = new ThreadTheMaze(5,5);        x.loadMaze();        x.solve(new Cell(5,5));        x.updateMaze();        x.printMaze();    }}Cell class: public class Cell{    private int row;    private int column;    Cell(){}    public Cell(int row, int column){        this.row = row;        this.column = column;    }    public int getRow(){        return row;    }    public int getColumn(){        return column;    }}mazeData.txt: ***************    ******** **  *******   *  ***** ***   *****  * ** ******** ***********   ********  *******    *  ***** ***  ****** *********** *********** **********Note: requirement was that beginning is always at (5,5).
Is this a true backtracking algorithm?
java;algorithm;backtracking