title: Creating a maze solving algorithm in Java
body: <p>I've been assigned with the task of creating a maze solver in Java. Here's the assignment:</p>
  
  <pre><code>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
  </code></pre>
  
  <p>The character 'X' represents a wall or a blocked position and the character 'O'     represents an
  open position.  You may assume that the entrance to the maze is always in the lower right hand 
  corner, and the exit is always in the upper left hand corner.  Your program should send its
  output to a file.  If a path is found the output file should contain the path.  If a path is
  not found a message should be sent to the file.  Please note that a maze may have more than 
  one solution path, but in this exercise you are only being asked to locate one solution, not
  all solutions.</p>
  
  <p>Your program should use a stack to record the path that it is exploring and backtrack when it
  reaches a blocked position.</p>
  
  <p>Be sure to write a complete algorithm before writing your code.  Feel free to create any additional
  classes that will help you complete the assignment.</p>
  
  <pre><code>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
  </code></pre>
  
  <p>Anyway, what I have set up is a Points class that has set/get methods for traveling in all cardinal directions which will return booleans as shown:</p>
  
  <pre><code>public class Points&lt;E&gt;
  {
  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;
  }
  </code></pre>
  
  <p>}</p>
  
  <p>I'm just having problems getting the actual solving down in the main. Here's what I have:</p>
  
  <pre><code>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&lt;ArrayList&lt;Points&gt;&gt; MAZE = new ArrayList&lt;ArrayList&lt;Points&gt;&gt;();
  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&lt;ArrayList&lt;Points&gt;&gt; temp = new ArrayList&lt;ArrayList&lt;Points&gt;&gt;();
  
          //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&lt;ArrayList&lt;Points&gt;&gt; hold = new ArrayList&lt;ArrayList&lt;Points&gt;&gt;();
      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&lt;Points&gt; st = new ArrayStack&lt;Points&gt;();
      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' &amp;&amp; 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' &amp;&amp; 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' &amp;&amp; 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&lt; st.size(); i++) {
      System.out.println(st.pop);
      i++
  }
  </code></pre>
  
  <p>Aside from any syntax errors, could you guys offer me some help? Thanks a lot.</p>