SP done. Submitting.

Author: nateuni

src/ass02/Board.java

@@ -2,6 +2,7 @@
 
 import java.util.ArrayList;
 import java.util.LinkedList;
+import java.util.List;
 import java.util.PriorityQueue;
 
 public class Board implements SlidingBlock {
@@ -11,11 +12,7 @@ public class Board implements SlidingBlock {
 	int[] board;
 	Node[] node;
 	int startPosition;
-	
-	
-	//PriorityQueue<Node> openSet;
-	//ArrayList<Node> closedSet;
-	
+
 	public Board(int n){
 		this.n = n;
 		board = new int[n*n];
@@ -31,8 +28,7 @@ public int[] solve(int[] start, int[] goal, int maxMoves) {
 	public int[] shortestPath(int startPosition) {
 		this.startPosition = startPosition;
 		initialiseSPNodes(startPosition);
-		this.aStar(node[startPosition], node[0], Integer.MAX_VALUE);
-		return null;
+		return this.aStar(node[startPosition], node[0], Integer.MAX_VALUE);
 	}
 
 	@Override
@@ -41,16 +37,7 @@ public void addWall(int positionI, int positionJ) {
 
 	}
 
-	public void initialiseBoard(int startPos){
-		for(int i = 0; i < this.board.length; i++){
-			if(i == startPos){
-				this.board[i] = 0;
-			} else{
-				this.board[i] = 1;
-			}
-		}
-	}
-	
+	// Initalise a node represention of the input array 
 	public void initialiseSPNodes(int startPos){
 		node = new SPNode[n*n];
 		for(int i = 0; i < this.node.length; i++){
@@ -74,40 +61,69 @@ public void initialiseSPNodes(int startPos){
 		node[0].setN(n);
 	}
 
+	// prints the board as a matrix
 	public void printBoardToConsole(){
 		for(int i = 0; i < this.node.length; i++){
-			System.out.print(this.node[i].location+"   ");
+			System.out.print(this.node[i].location+"  ");
+			if(this.node[i].location < 10) System.out.print(" ");
 			if((i+1) % n == 0){
 				System.out.print("\n");
 			}
 		}
 	}
 
+
+	/*
+	 * Return the node located above, if there is one
+	 */
 	public Node up(Node node){
 		if(node.indexOfUp() < 0) return null;
 		return this.node[node.indexOfUp()];
 	}
+	
+	/*
+	 * Return the node located below, if there is one
+	 */
 	public Node down(Node node){
 		if(node.indexOfDown() < 0) return null;
 		return this.node[node.indexOfDown()];
 	}
+	
+	/*
+	 * Return the node located on the left, if there is one
+	 */
 	public Node left(Node node){
 		if(node.indexOfLeft() < 0) return null;
 		return this.node[node.indexOfLeft()];
 	}
+	
+	/*
+	 * Return the node located on the right, if there is one
+	 */
 	public Node right(Node node){
 		if(node.indexOfRight() < 0) return null;
 		return this.node[node.indexOfRight()];
 	}
 
+	/*
+	 * Return the node from the stated position
+	 */
 	public Node getNode(int pos){
 		return node[pos];
 	}
 
+	/*
+	 * For the shortest path algo
+	 * 
+	 * Return true if the node is in the first row
+	 */
 	public boolean reachedGoal(Node node){
 		return node.location < n;
 	}
 
+	/*
+	 * Add directly attached nodes to a list for processing in A*
+	 */
 	public ArrayList<Node> getDirectlyAttachedNodes(Node n){
 		ArrayList<Node> list = new ArrayList<Node>();
 		if(this.up(n) != null) list.add(this.up(n));
@@ -117,56 +133,99 @@ public ArrayList<Node> getDirectlyAttachedNodes(Node n){
 		return list;
 	}
 
-
+	/* 
+	 * A* Algo from psuedo code from wikipedia
+	 * http://en.wikipedia.org/wiki/A*_search_algorithm
+	 */
 	private int[] aStar(Node startNode, Node goalNode, int maxLength) {
 		ArrayList<Node> closedSet = new ArrayList<Node>();
 		PriorityQueue<Node> openSet = new PriorityQueue<Node>();
-		startNode.h = this.heuristicDistance(startNode, goalNode);
-		int tempG;
+		
+		// When handling SPNodes
+		if(goalNode instanceof SPNode){
+			goalNode = node[startNode.col()];
+		}
+
+		int tentativeG;
 		Node current;
-		boolean yInOpenSet;
+		boolean tentativeBetter = false;
+		
+		//set details of start node
+		startNode.g = 0;
+		startNode.h = this.heuristicDistance(startNode, goalNode);
+		startNode.f = startNode.h;
+		
+		//add startNode to openset
+		openSet.add(startNode);
 
 		while (!openSet.isEmpty()) {
 			current = openSet.poll();
 			if(this.reachedGoal(current)){
-				System.out.print("done");
+				reconstructPath(current);
+				return this.toIntArray(this.path);
 			}
 			closedSet.add(current);
 			if (current.g >= maxLength) continue;
-			this.printBoardToConsole();
 			for (Node attached : getDirectlyAttachedNodes(current)) {
 				if (closedSet.contains(attached)) continue;
-				tempG = current.g + 1;
-				
-				yInOpenSet = false;
-				for (Node thisState : openSet) {
-					if (attached.equals(thisState)) {
-						attached = thisState;
-						yInOpenSet = true;
-					}
-				}
-				if (!yInOpenSet || tempG < attached.g) {
-					attached.parent = current;
-					attached.g = tempG;
-					attached.h = heuristicDistance(attached, goalNode);
-					attached.f = attached.g + attached.h;
-				}
-				if (!yInOpenSet && attached.f <= maxLength) openSet.add(attached);
+				tentativeG = current.g + 1;
+				if(!(openSet.contains(attached))){
+	                 tentativeBetter = true;
+				}else if(tentativeG < attached.g){
+	                 tentativeBetter = true;
+				}else{
+	                 tentativeBetter = false;
+	 			}
+	            if(tentativeBetter){
+	            	attached.parent = current;
+	            	attached.g = tentativeG;
+	            	attached.h = heuristicDistance(attached, goalNode);
+	                attached.f = attached.g + attached.h;
+	                openSet.add(attached);
+	           } 
 			}
 		}
-		
 		return null;
 	}
 
+	/*
+	 * Return the distance away in terms of the sum of the row and col dofferences
+	 */
 	private int heuristicDistance(Node from, Node to){
 		return(Math.abs(from.col() - to.col()) + Math.abs(from.row() - to.row()));
 	}
 
+	/*
+	 * Reconstruct the path to the start, the data is kept in a list
+	 */
 	public void reconstructPath(Node node){
 		if(node.parent != null){
 			reconstructPath(node.parent);
-		} else{
+		} 
 			path.add(node.location);
+	}
+	
+	/*
+	 * Return the Integer List as a primitive int array
+	 * code found at taken from here http://stackoverflow.com/questions/960431/how-to-convert-listinteger-to-int-in-java
+	 */
+	int[] toIntArray(List<Integer> list)  {
+	    int[] ret = new int[list.size()];
+	    int i = 0;
+	    for (Integer e : list)  
+	        ret[i++] = e.intValue();
+	    return ret;
+	}
+	
+	/*
+	 * Return array contents as a string
+	 */
+	public String arrayToString(int[] theArray){
+		if(theArray == null) return "";
+		StringBuilder arrayAsString = new StringBuilder();
+		for(int i = 0; i < theArray.length; i++){
+			arrayAsString.append(theArray[i]+" ");
 		}
+		return arrayAsString.toString();	
 	}
 }

src/ass02/Node.java

@@ -1,16 +1,14 @@
 package ass02;
 
-import java.util.Comparator;
-
-public abstract class Node implements Comparator<Node> {
+public abstract class Node implements Comparable<Node> {
 
+	// the values needed for the A*
 	static int n;
 	int g;
 	int h;
 	int f;
 	int location;
 	Node parent;
-	//boolean isHole;
 
 	public void setN(int nVal){
 		n = nVal;
@@ -20,18 +18,24 @@ public int getN(){
 		return n;
 	}
 
-	
 	public abstract int indexOfLeft();
 	public abstract int indexOfRight();
 	public abstract int indexOfUp();
 	public abstract int indexOfDown();
 	public abstract void setIndexesToOtherNodes();
 
+	/*
+	 * Returns the conceptual row value
+	 */
 	public int row(){
 		return (this.location - this.col()) / n;
 	}
 
+	/*
+	 * Returns the conceptual col value
+	 */
 	public int col(){
 		return this.location % n;
 	}
+	
 }

src/ass02/SBPuzzle.java

@@ -1,18 +1,12 @@
 package ass02;
 
 public class SBPuzzle {
-
+	
 	/**
 	 * @param args
 	 */
 	public static void main(String[] args) {
-		Board b = new Board(3);
-		b.initialiseBoard(8);
-		b.shortestPath(8);
-		b.printBoardToConsole();
-		//int i = b.getNode(8).indexOfUp();
-		//
-		//System.out.print(i);
+		Board b = new Board(4);
+		System.out.println(b.arrayToString(b.shortestPath(15)));
 	}
-
 }

src/ass02/SPNode.java

@@ -1,5 +1,6 @@
 package ass02;
 
+
 public class SPNode extends Node {
 	int up;
 	int down;
@@ -8,38 +9,51 @@ public class SPNode extends Node {
 
 	public SPNode(int dimensions){
 		n = dimensions;
-	}
-
-	@Override
-	public int compare(Node n1, Node n2) {
-		return n1.f - n2.f;
 	}	
 
+	/*
+	 * Finds the index of the left as if it was an actual matrix
+	 */
 	@Override
 	public int indexOfLeft(){
 		if(this.location % n == 0)
 			return -1;
 		return this.location - 1;
 	}
+	
+	/*
+	 * Finds the index of the right as if it was an actual matrix
+	 */
 	@Override
 	public int indexOfRight(){
 		if((this.location + 1) % n == 0)
 			return -1;
 		return this.location + 1;
 	}
+	
+	/*
+	 * Finds the index of the above as if it was an actual matrix
+	 */
 	@Override
 	public int indexOfUp(){
 		if(this.location - n < 0)
 			return -1;
 		return this.location - n;
 	}
+	
+	/*
+	 * Finds the index of the below as if it was an actual matrix
+	 */
 	@Override
 	public int indexOfDown(){
 		if(this.location + n >= (n*n))
 			return -1;
 		return this.location + n;
 	}
 
+	/*
+	 * Sets this node to know what indexes are around in 4 directions.
+	 */
 	@Override
 	public void setIndexesToOtherNodes() {
 		this.down = indexOfDown();
@@ -51,6 +65,14 @@ public void setIndexesToOtherNodes() {
 
 	@Override
 	public String toString(){
-		return "#:"+this.location+" up:"+this.up+" down:"+this.down+" left:"+this.left+" right:"+this.right;
+		return "\n#:"+this.location+" up:"+this.up+" down:"+this.down+" left:"+this.left+" right:"+this.right+" f:"+this.f+" g:"+this.g+" h:"+this.h;
+	}
+
+	/*
+	 * Used for evaluation of PriorityQueue
+	 */
+	@Override
+	public int compareTo(Node o1) {
+		return this.f - o1.f;
 	}
 }