Ajout de la classe abstraite 'Solver'

Author: Gabriel Derrien

bin/.gitignore

@@ -6,4 +6,5 @@
 /Main.class
 /Maze.class
 /Node.class
+/Solver.class
 /Square.class

bin/AStarSolver$1.class

@@ -2,26 +2,19 @@
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.PriorityQueue;
-import java.util.Queue;
 
-public class AStarSolver
+public class AStarSolver extends Solver
 {
-	private Maze maze;
-	private String result;
-	private Queue<Node<Maze>> openNodes;
-	private Queue<Square> closedSquares;
-	private int nodesCounter;
-	private int pathLength;
-	
 	/*
 	 * Constructor
 	 * m: The maze to solve
 	 */
-	public AStarSolver(Maze m)
+	public AStarSolver(Maze m, Boolean manhattan)
 	{
 		this.maze = m;
 		this.result = "";
-		this.openNodes = new PriorityQueue<Node<Maze>>(new Comparator<Node<Maze>>()
+		this.manhattan = manhattan; 
+		this.frontier = new PriorityQueue<Node<Maze>>(new Comparator<Node<Maze>>()
 		{
 			public int compare(Node<Maze> s1, Node<Maze> s2) 
 		    {
@@ -57,7 +50,7 @@ else if(cs1 == cs2)
 	 * Solves the maze with the A* algorithm
 	 * manhattan: Set as true to use the MANHATTAN DISTANCE instead of EUCLIDEAN DISTANCE 
 	 */
-	public void solve(boolean manhattan)
+	public void solve()
 	{
 		this.maze.initMaze(); //Re-init maze
 
@@ -74,35 +67,35 @@ public void solve(boolean manhattan)
 		this.maze.getStart().calcF();
 
 		//Init data structures
-		this.openNodes.clear(); //Clear openNodes Queue
-		this.openNodes.offer(new Node<Maze>(this.maze)); //Adding the first node (Start node) (G is at 0, Start to Start = 0)
+		this.frontier.clear(); //Clear frontier Queue
+		((PriorityQueue<Node<Maze>>) this.frontier).offer(new Node<Maze>(this.maze)); //Adding the first node (Start node) (G is at 0, Start to Start = 0)
 		this.closedSquares.clear(); //Clear closedSquares
 
 		//Measure run time
 		long startTime = System.currentTimeMillis();
 
 		while(!endfound)
 		{
-			if(this.openNodes.isEmpty())
+			if(this.frontier.isEmpty())
 				break;
 
 			else
 			{
-				Node<Maze> current = this.openNodes.remove();
+				Node<Maze> current = ((PriorityQueue<Node<Maze>>) this.frontier).remove();
 				this.maze = (Maze) current.getContent();
 				Square currState = this.maze.getCurrState();
 
 				if(currState.getCol() == this.maze.getEnd().getCol() && currState.getLine() == this.maze.getEnd().getLine())
 				{
 					Node<Maze> temp = new Node<Maze>(this.maze);
 					temp.setFather(current);
-					this.openNodes.offer(temp);
+					((PriorityQueue<Node<Maze>>) this.frontier).offer(temp);
 					endfound = true;
 				}
 
 				else
 				{
-					LinkedList<Node<Maze>> nexts = this.getNextSquares(manhattan);
+					LinkedList<Node<Maze>> nexts = this.getNextSquares();
 					if(!this.closedSquares.contains(currState))
 					{
 						this.closedSquares.add(currState);
@@ -119,10 +112,10 @@ public void solve(boolean manhattan)
 				    		continue;
 				    	else
 				    	{
-				    		if(!this.openNodes.contains(neighbor))
+				    		if(!this.frontier.contains(neighbor))
 				    		{
 				    			neighbor.setFather(current);
-				    			this.openNodes.offer(neighbor);
+				    			((PriorityQueue<Node<Maze>>) this.frontier).offer(neighbor);
 				    			this.nodesCounter++;
 				    		}
 				    	}
@@ -132,15 +125,14 @@ public void solve(boolean manhattan)
 		}
 		long endTime = System.currentTimeMillis();
 
-		this.setResult(endfound, manhattan, endTime - startTime);
+		this.setResult(endfound, endTime - startTime);
 	}
 
 	/*
 	 *  Get the next ("walkables") squares from the given square
 	 *  c: Square from where to get the nexts squares
-	 *  manhattan: If True, the distances computed will use the MANHATTAN DISTANCE instead of EUCLIDEAN DISTANCE
 	 */
-	public LinkedList<Node<Maze>> getNextSquares(Boolean manhattan)
+	public LinkedList<Node<Maze>> getNextSquares()
 	{
 		LinkedList<Node<Maze>> res = new LinkedList<Node<Maze>>();
 
@@ -154,7 +146,7 @@ public LinkedList<Node<Maze>> getNextSquares(Boolean manhattan)
 			Square tempSq = nexts.get(i).getCurrState();
 			if(!this.closedSquares.contains(tempSq))
 			{
-				if(manhattan)
+				if(this.manhattan)
 					nexts.get(i).getCurrState().calcManhattanH();
 				else
 					nexts.get(i).getCurrState().calcEuclidH();
@@ -180,9 +172,9 @@ public LinkedList<Node<Maze>> getNextSquares(Boolean manhattan)
 	 *  
 	 *  PRIVATE: This method must be called only at the end of the solve method. Any other call may throw errors.
 	 */
-	private void setResult(boolean success, boolean manhattan, long time)
+	private void setResult(boolean success, long time)
 	{
-		if(manhattan)
+		if(this.manhattan)
 			this.result = "    ___                    __  ___            __          __  __            \r\n" + 
 					"   /   | __/|_            /  |/  /___ _____  / /_  ____ _/ /_/ /_____ _____ \r\n" + 
 					"  / /| ||    /  ______   / /|_/ / __ `/ __ \\/ __ \\/ __ `/ __/ __/ __ `/ __ \\\r\n" + 
@@ -198,7 +190,7 @@ private void setResult(boolean success, boolean manhattan, long time)
 		if(success)
 		{
 			this.maze.resetGrid();
-			Node<Maze> revertedTree = this.openNodes.remove();
+			Node<Maze> revertedTree = ((PriorityQueue<Node<Maze>>) this.frontier).remove();
 
 			revertedTree = revertedTree.getFather();
 			this.result += "Path: " + this.maze.getEnd().toString() + "(End) <- ";

bin/AStarSolver$2.class

@@ -1,14 +1,8 @@
 import java.util.Iterator;
 import java.util.LinkedList;
 
-public class BFS_Solver
+public class BFS_Solver extends Solver
 {
-	private Maze maze;
-	private String result;
-	private LinkedList<Node<Maze>> frontier;
-	private LinkedList<Square> closedSquares;
-	private int nodesCounter;
-	private int pathLength;
 
 	/*
 	 * Constructor
@@ -50,7 +44,7 @@ public void solve()
 
 			else
 			{
-				Node<Maze> current = this.frontier.removeFirst(); //Get first node from the frontier
+				Node<Maze> current = ((LinkedList<Node<Maze>>) this.frontier).removeFirst(); //Get first node from the frontier
 				this.maze = (Maze) current.getContent(); //Get maze from the node
 				Square currState = this.maze.getCurrState(); //Get current state from the maze
 
@@ -140,7 +134,7 @@ private void setResult(boolean success, long time)
 		if(success)
 		{
 			this.maze.resetGrid();
-			Node<Maze> revertedTree = this.frontier.removeLast();
+			Node<Maze> revertedTree = ((LinkedList<Node<Maze>>) this.frontier).removeLast();
 
 			revertedTree = revertedTree.getFather();
 			this.result += "Path: " + this.maze.getEnd().toString() + "(End) <- ";
@@ -180,23 +174,11 @@ public String getResult()
 			return this.result;
 	}
 
-	/*
-	 * Returns all the closed nodes in a string
-	 */
-	public String printClosedNodes()
-	{
-		String res = "Closed nodes : \n";
-		for(int i = 0; i < this.closedSquares.size(); i++)
-			res += "(" + i + ") " + this.closedSquares.get(i).toString() + "\n";
-		
-		return res;
-	}
-	
 	/*
 	 * Returns the frontier from the last solving
 	 */
 	public LinkedList<Node<Maze>> getFrontier() 
 	{
-		return this.frontier;
+		return (LinkedList<Node<Maze>>) this.frontier;
 	}
 }

bin/AStarSolver.class

@@ -2,14 +2,10 @@
 import java.util.LinkedList;
 import java.util.Stack;
 
-public class DFS_Solver
+public class DFS_Solver extends Solver
 {
-	private Maze maze;
-	private String result;
-	private Stack<Node<Maze>> frontier;
-	private Stack<Square> closedSquares;
-	private int nodesCounter;
-	private int pathLength;
+	/*private Stack<Node<Maze>> frontier;
+	private Stack<Square> closedSquares;*/
 
 	/*
 	 * Constructor
@@ -38,7 +34,7 @@ public void solve()
 
 		//Init frontier
 		this.frontier.clear();
-		this.frontier.push(new Node<Maze>(this.maze)); //Add first state
+		((Stack<Node<Maze>>) this.frontier).push(new Node<Maze>(this.maze)); //Add first state
 
 		//Measure run time
 		long startTime = System.currentTimeMillis();
@@ -51,15 +47,15 @@ public void solve()
 
 			else
 			{
-				Node<Maze> current = this.frontier.pop(); //Get first node from the frontier
+				Node<Maze> current = ((Stack<Node<Maze>>) this.frontier).pop(); //Get first node from the frontier
 				this.maze = (Maze) current.getContent();
 				Square currState = this.maze.getCurrState();
 
 				if(currState.getLine() == this.maze.getEnd().getLine() && currState.getCol() == this.maze.getEnd().getCol())
 				{
 					Node<Maze> temp = new Node<Maze>(this.maze);
 					temp.setFather(current);
-					this.frontier.push(temp);
+					((Stack<Node<Maze>>) this.frontier).push(temp);
 					endfound = true;
 				}	
 
@@ -68,7 +64,7 @@ public void solve()
 					LinkedList<Node<Maze>> nexts = this.getNextSquares(); //Get next possible states
 					if(!this.closedSquares.contains(currState))
 					{
-						this.closedSquares.push(currState);
+						((Stack<Square>) this.closedSquares).push(currState);
 						currState.setAttribute("*");
 					}
 
@@ -78,7 +74,7 @@ public void solve()
 					{
 						Node<Maze> temp = x.next();
 						temp.setFather(current);
-						this.frontier.push(temp);
+						((Stack<Node<Maze>>) this.frontier).push(temp);
 						this.nodesCounter++;
 					}
 				}
@@ -135,7 +131,7 @@ private void setResult(boolean success, long time)
 		if(success)
 		{
 			this.maze.initMaze();
-			Node<Maze> revertedTree = this.frontier.pop();
+			Node<Maze> revertedTree = ((Stack<Node<Maze>>) this.frontier).pop();
 
 			this.result += "Path: " + this.maze.getEnd().toString() + "(End) <- ";
 			this.pathLength++;
@@ -171,14 +167,14 @@ public String getResult()
 		if(result == "")
 			return "No resolution computed, please use DFS_Solver.solve() first";
 		else
-			return result;
+			return this.result;
 	}
 
 	/*
 	 * Returns the frontier from the last solving
 	 */
 	public Stack<Node<Maze>> getFrontier() 
 	{
-		return this.frontier;
+		return (Stack<Node<Maze>>) this.frontier;
 	}
 }

bin/BFS_Solver.class

@@ -31,17 +31,19 @@ public static void main(String[] args) throws IOException
 
 		BFS_Solver b2 = new BFS_Solver(lab2);
 		DFS_Solver d2 = new DFS_Solver(lab2);
-		AStarSolver a2 = new AStarSolver(lab2);
+		AStarSolver a2 = new AStarSolver(lab2, true);
 
 		b2.solve();
 		d2.solve();
-		a2.solve(true);
+		a2.solve();
 
 		System.out.println(b2.getResult());
 		System.out.println(d2.getResult());
 		System.out.println(a2.getResult());
 
-		a2.solve(false);
+		a2 = new AStarSolver(lab2, false);
+		
+		a2.solve();
 		System.out.println(a2.getResult());
 	}
 }

bin/DFS_Solver.class

@@ -39,7 +39,6 @@ public Maze(int lRange, int cRange, Square start, Square end)
 
 		//Create start and end MazeState objects contaning the start and end squares (stated)
 		this.end = end;
-		this.end.depth = 0;
 		this.start = start;
 
 		this.currState = this.getStart();

bin/Main.class

@@ -0,0 +1,19 @@
+import java.util.AbstractCollection;
+import java.util.LinkedList;
+
+public abstract class Solver 
+{
+	protected Maze maze;
+	protected String result;
+	protected AbstractCollection<Node<Maze>> frontier;
+	protected AbstractCollection<Square> closedSquares;
+	protected int nodesCounter;
+	protected int pathLength;
+	protected Boolean manhattan;
+	
+	public abstract void solve();
+	
+	public abstract LinkedList<Node<Maze>> getNextSquares();
+	
+	public abstract String getResult();
+}

bin/Maze.class

@@ -8,7 +8,6 @@ public class Square
 	private int c;
 	private String attribute;
 	private boolean wall;
-	public int depth;
 
 	private int g;
 	private double h;
@@ -33,7 +32,6 @@ public Square(int l, int c, String a)
 		this.c = c;
 		this.attribute = a; //S = Start; E = End; ' ' = Playable; * = Closed
 		this.wall = false;
-		this.depth = 0;
 		this.g = 0;
 		this.h = 0;
 		this.f = 0;