From 1b9af7a6ade3963ae7bc5933bd5f61de22ddc36d Mon Sep 17 00:00:00 2001 From: Jonathan Turner Date: Sat, 10 Feb 2024 08:36:18 -0500 Subject: [PATCH] Mid fix of Heuristics and UCS/BFS. --- .idea/misc.xml | 1 - src/Assignments/A1/Driver.java | 28 ++++++- src/Assignments/A1/models/BoardNode.java | 79 +++++++++++++++++++ .../A1/solving_algorithms/AStar.java | 40 ++++++++++ .../A1/solving_algorithms/BFS.java | 74 ++++------------- .../A1/solving_algorithms/DFS.java | 6 +- .../A1/solving_algorithms/UCS.java | 43 ++++++++++ 7 files changed, 204 insertions(+), 67 deletions(-) create mode 100644 src/Assignments/A1/models/BoardNode.java diff --git a/.idea/misc.xml b/.idea/misc.xml index 03f397c..ca950ab 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -1,4 +1,3 @@ - diff --git a/src/Assignments/A1/Driver.java b/src/Assignments/A1/Driver.java index 4470e2c..d5cccb4 100644 --- a/src/Assignments/A1/Driver.java +++ b/src/Assignments/A1/Driver.java @@ -4,8 +4,10 @@ package Assignments.A1; import Assignments.A1.models.Board; import Assignments.A1.models.BoardGenerator; +import Assignments.A1.models.BoardNode; import Assignments.A1.solving_algorithms.BFS; import Assignments.A1.solving_algorithms.DFS; +import Assignments.A1.solving_algorithms.UCS; import java.util.ArrayList; import java.util.Date; @@ -19,6 +21,10 @@ import java.util.concurrent.TimeUnit; * 3 4 5 * 6 7 8 * + * 1 2 3 + * 8 0 4 + * 7 6 5 + * * The values will be specified with an int. Must be between (inclusive) 1-8. * The empty spot will be represented with null. */ @@ -27,10 +33,12 @@ public class Driver { public static void main(String[] args) { ArrayList timer = new ArrayList<>(); int successes = 0; - for (int run = 0; run < 100; run++) { + int runs = 1; + for (int run = 0; run < runs; run++) { Board board = BoardGenerator.generateBoard(); // DFS solver = new DFS(); BFS solver = new BFS(); +// UCS solver = new UCS(); Date start = new Date(); Board result = solver.traverse(board); Date end = new Date(); @@ -38,6 +46,15 @@ public class Driver { long runtime = end.getTime() - start.getTime(); timer.add(runtime); successes++; + String test = "END"; + System.out.println(solver.test.heuristic); + BoardNode curr = solver.test; + while (curr != null) { + test = curr.board.toString() + " -> " + test; + curr = curr.parent; + } + System.out.println(test); + System.out.println(); } } long total = 0; @@ -47,7 +64,14 @@ public class Driver { } long average = total / (long) timer.size(); System.out.println("Average Runtime: " + average); - System.out.println("Number of successful solves: " + successes + "/100"); + System.out.println("Number of successful solves: " + successes + "/" + runs); } + +// public static void main(String[] args) { +// int[] values = {1, 2, 3, 8, 0, 5, 4, 7, 6}; +// BoardNode node = new BoardNode(new Board(values), null); +// System.out.println(node.heuristic); +// } + } diff --git a/src/Assignments/A1/models/BoardNode.java b/src/Assignments/A1/models/BoardNode.java new file mode 100644 index 0000000..f83b8c5 --- /dev/null +++ b/src/Assignments/A1/models/BoardNode.java @@ -0,0 +1,79 @@ +package Assignments.A1.models; + +public class BoardNode implements Comparable { + + public BoardNode parent; + public int heuristic; + public int cost; + public Board board; + public List + + public BoardNode(Board board, BoardNode parent) { + this.board = board; + this.parent = parent; + this.heuristic = this.getHeuristic(); + this.cost = this.getActualCost(); + } + + private int getActualCost() { + if (this.parent != null) { + return this.parent.cost + 1; + } else { + return 0; + } + } + + + private int getHeuristic() { + int cost = 0; + for (int i = 0; i < 9; i++) { + int currValue = board.getPiece(i); + int idealIndex = idealIndex(currValue); + int currRow = i / 3; + int currCol = i % 3; + int idealRow = idealIndex / 3; + int idealCol = idealIndex % 3; + cost += Math.abs(idealRow - currRow) + Math.abs(idealCol - currCol); + } + return cost; + } + + private int idealIndex(int value) { + int result = -1; + switch (value) { + case 0: + result = 4; + break; + case 1: + result = 0; + break; + case 2: + result = 1; + break; + case 3: + result = 2; + break; + case 4: + result = 5; + break; + case 5: + result = 8; + break; + case 6: + result = 7; + break; + case 7: + result = 6; + break; + case 8: + result = 3; + break; + } + return result; + } + + @Override + public int compareTo(BoardNode o) { // BFS + return Integer.compare(this.heuristic, o.heuristic); + } +} diff --git a/src/Assignments/A1/solving_algorithms/AStar.java b/src/Assignments/A1/solving_algorithms/AStar.java index 93a9d90..28dcc32 100644 --- a/src/Assignments/A1/solving_algorithms/AStar.java +++ b/src/Assignments/A1/solving_algorithms/AStar.java @@ -1,4 +1,44 @@ package Assignments.A1.solving_algorithms; +import Assignments.A1.models.Board; +import Assignments.A1.models.BoardNode; +import Assignments.A1.models.Move; + +import java.util.Comparator; +import java.util.HashSet; +import java.util.List; +import java.util.PriorityQueue; + public class AStar { + private final Board solved = new Board(); + private final HashSet visited = new HashSet<>(); + + public Board traverse(Board root) { + PriorityQueue boards = new PriorityQueue<>(new UCSPriority()); + boards.add(new BoardNode(root, null)); + BoardNode node = null; + Board current = new Board(root); + while (!current.equals(solved)) { + node = boards.poll(); + current = node.board; + if (visited.contains(node.board)) { + continue; + } + visited.add(node.board); + List children = node.board.getMoves(); + for (Move move : children) { + Board child = new Board(node.board); + child.swap(move); + boards.add(new BoardNode(child, node)); + } + } + return node.board; + } +} + +class AStarPriority implements Comparator { + @Override + public int compare(BoardNode o1, BoardNode o2) { + return Integer.compare(o2.cost, o1.cost); + } } diff --git a/src/Assignments/A1/solving_algorithms/BFS.java b/src/Assignments/A1/solving_algorithms/BFS.java index 656879a..c37fb95 100644 --- a/src/Assignments/A1/solving_algorithms/BFS.java +++ b/src/Assignments/A1/solving_algorithms/BFS.java @@ -1,8 +1,10 @@ package Assignments.A1.solving_algorithms; import Assignments.A1.models.Board; +import Assignments.A1.models.BoardNode; import Assignments.A1.models.Move; +import java.util.Comparator; import java.util.HashSet; import java.util.List; import java.util.PriorityQueue; @@ -11,13 +13,16 @@ public class BFS { private final Board solved = new Board(); private final HashSet visited = new HashSet<>(); + public BoardNode test; public Board traverse(Board root) { - PriorityQueue boards = new PriorityQueue<>(); - boards.add(new BoardNode(root)); + PriorityQueue boards = new PriorityQueue<>(new BFSPriority()); + boards.add(new BoardNode(root, null)); BoardNode node = null; - while (!boards.isEmpty()) { + Board current = new Board(root); + while (!current.equals(solved)) { node = boards.poll(); + current = node.board; if (visited.contains(node.board)) { continue; } @@ -26,69 +31,18 @@ public class BFS { for (Move move : children) { Board child = new Board(node.board); child.swap(move); - boards.add(new BoardNode(child)); + boards.add(new BoardNode(child, node)); } } + test = node; return node.board; } } -class BoardNode implements Comparable { - - public int heuristic; - public Board board; - - public BoardNode(Board board) { - this.heuristic = this.getCost(board); - this.board = board; - } - - private int getCost(Board board) { - int cost = 0; - for (int i = 0; i < 9; i++) { - int currValue = board.getPiece(i); - cost += Math.abs(i - this.idealIndex(i)); - } - return cost; - } - - private int idealIndex(int value) { - int result = -1; - switch(value) { - case 0: - result = 4; - break; - case 1: - result = 0; - break; - case 2: - result = 1; - break; - case 3: - result = 2; - break; - case 4: - result = 5; - break; - case 5: - result = 8; - break; - case 6: - result = 7; - break; - case 7: - result = 6; - break; - case 8: - result = 3; - break; - - } - return result; - } - +class BFSPriority implements Comparator { @Override - public int compareTo(BoardNode o) { - return Integer.compare(this.heuristic, o.heuristic); + public int compare(BoardNode o1, BoardNode o2) { + return Integer.compare(o1.heuristic, o2.heuristic); } } + diff --git a/src/Assignments/A1/solving_algorithms/DFS.java b/src/Assignments/A1/solving_algorithms/DFS.java index 70790fa..643fff9 100644 --- a/src/Assignments/A1/solving_algorithms/DFS.java +++ b/src/Assignments/A1/solving_algorithms/DFS.java @@ -11,9 +11,8 @@ import java.util.*; public class DFS { - private int counter = 0; private final Board solved = new Board(); - private List tried = new ArrayList<>(); + private final List tried = new ArrayList<>(); /* Commented out for future reference. */ // public Board dfs(Board root, int depth, ArrayList visited) { @@ -44,8 +43,7 @@ public class DFS { // return null; // } - public Board dfs(Board root, int depth) { - counter++; + public Board traverse(Board root, int depth) { Stack stack = new Stack<>(); stack.push(root); diff --git a/src/Assignments/A1/solving_algorithms/UCS.java b/src/Assignments/A1/solving_algorithms/UCS.java index 69a09cf..6fcabab 100644 --- a/src/Assignments/A1/solving_algorithms/UCS.java +++ b/src/Assignments/A1/solving_algorithms/UCS.java @@ -1,4 +1,47 @@ package Assignments.A1.solving_algorithms; +import Assignments.A1.models.Board; +import Assignments.A1.models.BoardNode; +import Assignments.A1.models.Move; + +import java.util.Comparator; +import java.util.HashSet; +import java.util.List; +import java.util.PriorityQueue; + public class UCS { + private final Board solved = new Board(); + private final HashSet visited = new HashSet<>(); + + public BoardNode test = null; + + public Board traverse(Board root) { + PriorityQueue boards = new PriorityQueue<>(new UCSPriority()); + boards.add(new BoardNode(root, null)); + BoardNode node = null; + Board current = new Board(root); + while (!current.equals(solved)) { + node = boards.poll(); + current = node.board; + if (visited.contains(node.board)) { + continue; + } + visited.add(node.board); + List children = node.board.getMoves(); + for (Move move : children) { + Board child = new Board(node.board); + child.swap(move); + boards.add(new BoardNode(child, node)); + } + } + test = node; + return node.board; + } } + +class UCSPriority implements Comparator { + @Override + public int compare(BoardNode o1, BoardNode o2) { + return Integer.compare(o1.cost, o2.cost); + } +} \ No newline at end of file