added solve method to Solver

src/model/Board.java

@@ -34,4 +34,14 @@ public class Board {
 	public int getCarsNumber() {
 		return cars.length;
 	}
+
+	public int[][] getBoard()
+	{
+		return board;
+	}
+
+	public void setBoard(int[][] board)
+	{
+		this.board = board;
+	}
 }

src/model/Solver.java

 package model;
 
-import java.util.List;
-import java.util.PriorityQueue;
-import java.util.Queue;
+import java.util.*;
 
+/**
+ * Solve the problem using A*
+ */
 public class Solver {
 	private Queue<State> states;
 	private State currentState;
 	private Board board;
 
+	/**
+	 * Create a new Solver. call the solve method to start solving the problem
+	 */
 	public Solver(Board board)
 	{
 		this.states = new PriorityQueue<>();
@@ -16,14 +20,42 @@ public class Solver {
 		this.currentState = null;
 	}
 
-	public List<Move> solve()
+	/**
+	 * Solve the problem
+	 * @param resetBoard If the board should be in its initial state at the end of the algorithm
+	 * @return A Queue of moves so that the first move in the list is the first move you should play at the beginning of the game. Or null if the game has no solutions.
+	 */
+	public Deque<Move> solve(boolean resetBoard)
 	{
+		this.currentState = null;
+		this.states.add(new State(board, null, null));
+
+		// Executing A* until we find a solution or we explored all of the tree
+		while((!board.isSolved()) && (!states.isEmpty()))
+			aStar();
+
+		// Construction of the resulting move list
+		if(board.isSolved())
+		{
+			State s = currentState;
+			Deque<Move> result = new ArrayDeque<>();
+			while(s != null)
+			{
+				if (s.getMove() != null)
+				{
+					result.addFirst(s.getMove());
+					if(resetBoard)
+						s.getMove().getOpposite().play(board.getBoard());
+				}
+				s = s.getParent();
+			}
+			return result;
+		}
 
-		//TODO: 4/27/16
 		return null;
 	}
 
-	private void AStar()
+	private void aStar()
 	{
 
 	}

src/model/State.java

@@ -6,12 +6,12 @@ public class State implements Comparable<State>
 	private Move move;
 	private State parent;
 
-	public State(int[][] board, Move move, State parent)
+	public State(Board board, Move move, State parent)
 	{
 		this.move = move;
 		this.parent = parent;
 		this.cost = parent.cost + 1;
-		this.heuristic = naiveHeuristic(board);
+		this.heuristic = naiveHeuristic(board.getBoard());
 	}
 
 	public State getParent()