Turner/CS3642-Artificial_Intelligence
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: Turner:41c04cacecce38cf1b350b66ccfc34150a52b4f8
Branches Tags
Turner:master
Turner:dev
..
compare: Turner:dbfe4c6fe8b25a73d5f4cf170bce5e5dc86bb2c9
Branches Tags
Turner:dev
Turner:master

2 Commits
41c04cacec ... dbfe4c6fe8

Author SHA1 Message Date
Jonathan Turner
dbfe4c6fe8 DFS is fully working, not finished (fine tune results at end) Output file for #d8bea791 filetype. 2024-02-07 01:04:09 -05:00
Jonathan Turner
d8bea791fb Still development of DFS, nonfunctional. Pushing to access on other device. 2024-02-07 01:01:13 -05:00
4 changed files with 182 additions and 102 deletions
Show Stats Expand all files Collapse all files

37
src/Assignments/A1/Driver.java
View File

@ -2,13 +2,13 @@ package Assignments.A1;
// Potentially will be changed to an UI Implementation with JavaFX if time permits.
import Assignments.A1.models.BoardGenerator;
import Assignments.A1.models.Board;
import Assignments.A1.models.Piece;
import Assignments.A1.models.BoardGenerator;
import Assignments.A1.solving_algorithms.DFS;
import java.util.ArrayList;
import java.util.Date;
import java.util.concurrent.TimeUnit;
/**
* Board will be used to save locations in a 2D array.
@ -24,16 +24,29 @@ import java.util.ArrayList;
public class Driver {
public static void main(String[] args) {
DFS solver = new DFS();
Board board = BoardGenerator.generateBoard();
boolean result = solver.traverse(board);
int count = 0;
while (count != 100 || !result) {
result = solver.traverse(board);
System.out.println(count);
count++;
board = BoardGenerator.generateBoard();
ArrayList<Long> timer = new ArrayList<>();
int successes = 0;
for (int run = 0; run < 100; run++) {
Board board = BoardGenerator.generateBoard();
DFS solver = new DFS();
Date start = new Date();
Board result = solver.dfs(board,0);
Date end = new Date();
if (result != null) {
System.out.println("solved");
long runtime = end.getTime() - start.getTime();
timer.add(runtime);
successes++;
}
}
long total = 0;
for (int i = 0; i < timer.size(); i++) {
total += timer.get(i);
System.out.println("Run " + (i+1) + ": " + timer.get(i));
}
long average = total / (long) timer.size();
System.out.println("Average Runtime: " + average);
System.out.println("Number of successful solves: " + successes + "/100");
}
}

14
src/Assignments/A1/models/BoardGenerator.java
View File

@ -21,12 +21,14 @@ public class BoardGenerator {
public static Board generateBoard() {
Board ideal = new Board();
Random random = new Random();
int numOfMoves = random.nextInt(30,50);
for (int i = 0; i < numOfMoves; i++) {
List<Move> moves = ideal.getMoves();
Move randomMove = moves.get(random.nextInt(moves.size()));
ideal.swap(randomMove);
}
do {
int numOfMoves = random.nextInt(100, 150);
for (int i = 0; i < numOfMoves; i++) {
List<Move> moves = ideal.getMoves();
Move randomMove = moves.get(random.nextInt(moves.size()));
ideal.swap(randomMove);
}
} while (ideal.equals(new Board()));
return ideal;
}
}

103
src/Assignments/A1/performance_stats/DFS.txt Normal file
View File

@ -0,0 +1,103 @@
Run from #d8bea791: (Time in Milliseconds)
Run 1: 5677
Run 2: 1012
Run 3: 17058
Run 4: 11860
Run 5: 45404
Run 6: 10
Run 7: 10250
Run 8: 29170
Run 9: 26660
Run 10: 22485
Run 11: 5372
Run 12: 28510
Run 13: 1269
Run 14: 37239
Run 15: 3
Run 16: 36978
Run 17: 38774
Run 18: 42041
Run 19: 662
Run 20: 2951
Run 21: 11334
Run 22: 1581
Run 23: 1738
Run 24: 2604
Run 25: 17161
Run 26: 5572
Run 27: 14
Run 28: 8316
Run 29: 25494
Run 30: 7669
Run 31: 43046
Run 32: 20427
Run 33: 16146
Run 34: 30095
Run 35: 11381
Run 36: 0
Run 37: 1366
Run 38: 10928
Run 39: 529
Run 40: 10643
Run 41: 19734
Run 42: 3631
Run 43: 17513
Run 44: 3892
Run 45: 21224
Run 46: 105
Run 47: 30568
Run 48: 5313
Run 49: 6464
Run 50: 21124
Run 51: 31758
Run 52: 1619
Run 53: 35134
Run 54: 20679
Run 55: 98
Run 56: 2760
Run 57: 13905
Run 58: 15965
Run 59: 39522
Run 60: 2
Run 61: 2293
Run 62: 41910
Run 63: 17853
Run 64: 2950
Run 65: 56304
Run 66: 45523
Run 67: 17346
Run 68: 10577
Run 69: 703
Run 70: 324
Run 71: 1081
Run 72: 3846
Run 73: 13315
Run 74: 28206
Run 75: 47831
Run 76: 7488
Run 77: 12499
Run 78: 17101
Run 79: 7968
Run 80: 8936
Run 81: 1494
Run 82: 0
Run 83: 19235
Run 84: 15755
Run 85: 4979
Run 86: 22015
Run 87: 11589
Run 88: 27377
Run 89: 16111
Run 90: 25775
Run 91: 7022
Run 92: 27261
Run 93: 6351
Run 94: 26618
Run 95: 4594
Run 96: 13039
Run 97: 23729
Run 98: 16315
Run 99: 35539
Run 100: 2126
Average Runtime: 15314
Number of successful solves: 100/100

130
src/Assignments/A1/solving_algorithms/DFS.java
View File

@ -15,96 +15,58 @@ public class DFS {
private final Board solved = new Board();
private List<String> tried = new ArrayList<>();
public Board dfs(Board root, int depth, ArrayList<String> visited) {
/* Commented out for future reference. */
// public Board dfs(Board root, int depth, ArrayList<String> visited) {
// counter++;
// if (root.equals(solved)) {
// return root;
// }
//
// ArrayList<String> directParents = new ArrayList<>(visited);
// if (depth == Parameters.MAX_DEPTH || visited.contains(root.toString()) || tried.contains(root.toString())) {
// return null;
// }
// directParents.add(root.toString());
// tried.add(root.toString());
//
// List<Move> moves = root.getMoves();
// int moveNum = 1;
// for (Move next : moves) {
//
// Board child = next.getBoard();
// child.swap(next);
// moveNum++;
// Board board = dfs(child, depth+1, directParents);
// if (board != null) {
// return board;
// }
// }
// return null;
// }
public Board dfs(Board root, int depth) {
counter++;
if (root.equals(solved)) {
return root;
}
Stack<Board> stack = new Stack<>();
stack.push(root);
ArrayList<String> directParents = new ArrayList<>(visited);
if (depth == Parameters.MAX_DEPTH || visited.contains(root.toString()) || tried.contains(root.toString())) {
return null;
}
directParents.add(root.toString());
tried.add(root.toString());
while (!stack.isEmpty()) {
Board current = stack.pop();
if (current.equals(solved)) {
return current;
}
List<Move> moves = root.getMoves();
int moveNum = 1;
for (Move next : moves) {
if (depth == Parameters.MAX_DEPTH || tried.contains(current.toString())) {
continue;
}
tried.add(current.toString());
Board child = next.getBoard();
child.swap(next);
moveNum++;
Board board = dfs(child, depth+1, directParents);
if (board != null) {
return board;
List<Move> moves = current.getMoves();
for (Move next : moves) {
Board child = next.getBoard();
child.swap(next);
stack.push(child);
}
}
return null;
}
public boolean traverse(Board root) {
BoardNode current = new BoardNode(root);
Stack<BoardNode> lvr = new Stack<>();
lvr.push(current);
while (!lvr.isEmpty()) {
BoardNode curr = lvr.pop();
if (curr.board.equals(solved)) {
return true;
}
List<Move> moves = curr.board.getMoves();
for (Move move : moves) {
Board child = new Board(curr.board);
child.swap(move);
if (!curr.hasAncestor(child)) {
BoardNode childNode = new BoardNode(child, curr);
curr.addChild(childNode);
lvr.add(childNode);
}
}
}
return false;
}
}
class BoardNode {
public Board board;
public BoardNode parent;
public List<BoardNode> children;
public BoardNode(Board child, BoardNode parent) {
this.board = child;
this.parent = parent;
this.children = new ArrayList<>();
}
public BoardNode (Board child) {
this.board = child;
this.parent = null;
this.children = new ArrayList<>();
}
public boolean hasAncestor(Board board) {
BoardNode current = this;
while (current.parent != null) {
current = current.parent;
if (current.board.equals(board)) {
return true;
}
}
return false;
}
public void addChild(BoardNode child) {
if (child != null) {
children.add(child);
}
}
}