Finished up the assignment and fixed a bug in transition table generation and Hopcroft minimization

Author: Sean-Powell

.idea/modules.xml

@@ -0,0 +1,57 @@
+
+import java.util.ArrayList;
+
+class BreadthFirstSearch {
+    private int[] shortestPath;
+
+    ArrayList<Integer> Bfs(int[][] transitionTable, int startIndex) {
+        shortestPath = new int[transitionTable.length];
+        for (int i = 0; i < shortestPath.length; i++) {
+            shortestPath[i] = -1;
+        }
+
+        createPaths(startIndex, null, transitionTable);
+
+        ArrayList<Integer> unreachable = new ArrayList<>();
+        int max = Integer.MIN_VALUE;
+        for (int j = 0; j < shortestPath.length; j++) {
+            int currentPathLength = shortestPath[j];
+            if (currentPathLength > max) {
+                max = currentPathLength;
+            }
+
+            if(currentPathLength == -1){
+                unreachable.add(j);
+            }
+        }
+
+        System.out.println("Depth of tree is " + max);
+        System.out.println("The dfsa has " + transitionTable.length + " states");
+
+        return unreachable;
+    }
+
+    private void createPaths(int index, Path path, int[][] transitionTable) {
+        if (path == null) {
+            path = new Path();
+        }
+
+        if (!path.checkVisited(index)) {
+            path.addVisited(index);
+        } else {
+            return;
+        }
+
+        if (shortestPath[index] == -1 || shortestPath[index] > path.getCurrentLength()) {
+            shortestPath[index] = path.getCurrentLength();
+        }
+
+        path.incrementLength();
+        if (transitionTable[index][0] != -1) {
+            createPaths(transitionTable[index][0], path, transitionTable);
+        }
+        if (transitionTable[index][1] != -1) {
+            createPaths(transitionTable[index][1], path, transitionTable);
+        }
+    }
+}

.idea/uiDesigner.xml

@@ -1,4 +1,3 @@
-package NonBrokenHopefully;
 
 import java.util.Random;
 
@@ -32,10 +31,6 @@ void generateTransitions(){
                 transitions[i][2] = 1;
             }
         }
-
-        for(int i = 0; i < transitions.length; i++){
-            System.out.println(i + " - a: " + transitions[i][0] + ", b: " + transitions[i][1]);
-        }
     }
 
     void setTransitions(int[][] transitions){

src/BFS.java

@@ -1,4 +1,3 @@
-package NonBrokenHopefully;
 
 import java.util.ArrayList;
 import java.util.ListIterator;
@@ -36,10 +35,11 @@ DFSA hopcroft(DFSA dfsa, int startState){
 //            setDifferenceCalculation(P, W, x);
         }
 
-        int[][] newTransitionTable = createTransitionTable(P, dfsa.getTransitionTable());
+        int[][] reconstructedTransitionTable = reconstructTransitionTable(P, dfsa.getTransitionTable());
         int newStartState = findStartState(P, startState);
-        DFSA m = new DFSA(newTransitionTable.length, newStartState);
-        m.setTransitions(newTransitionTable);
+
+        DFSA m = new DFSA(reconstructedTransitionTable.length, newStartState);
+        m.setTransitions(reconstructedTransitionTable);
 
         return m;
     }
@@ -129,40 +129,36 @@ private ArrayList<Integer> division(ArrayList<Integer> x, ArrayList<Integer> y){
         return division;
     }
 
-    //todo try fix this, then hopcroft works correctly
-    private int[][] createTransitionTable(ArrayList<ArrayList<Integer>> P, int[][] originalTransitions){ //i don't think this works correctly
+    private int[][] reconstructTransitionTable(ArrayList<ArrayList<Integer>> P, int[][] originalTransitions) {
         int[][] transitionTable = new int[P.size()][3];
-
-        for(int i = 0; i < P.size(); i++){
+        for (int i = 0; i < P.size(); i++) {
             ArrayList<Integer> list = P.get(i);
-            int newATransition = -1;
-            int newBTransition = -1;
-            for(int j = 0; j < list.size(); j++){
-                int aTransition = originalTransitions[j][0];
-                int bTransition = originalTransitions[j][1];
-
-                for(int k = 0; k < P.size(); k++){
-                    ArrayList<Integer> list_b = P.get(k);
-                    if(list_b.contains(aTransition)){
-                        newATransition = k;
-                    }
 
-                    if(list_b.contains(bTransition)){
-                        newBTransition = k;
-                    }
+            int newConnectionA = -1;
+            int newConnectionB = -1;
 
-                    transitionTable[k][0] = newATransition;
-                    transitionTable[k][1] = newBTransition;
+            for (int node : list) {
+                int oldConnectionA = originalTransitions[node][0];
+                int oldConnectionB = originalTransitions[node][1];
+                int TF = originalTransitions[node][2];
 
-                    for(Integer integer: list_b){
-                        if(originalTransitions[integer][2] == 1) {
-                            transitionTable[k][2] = 1;
-                        }else{
-                            transitionTable[k][2] = 0;
-                        }
+                if(TF == 1){
+                    transitionTable[i][2] = 1;
+                }
+
+                for(int j = 0; j < P.size(); j++){
+                    if(P.get(j).contains(oldConnectionA)){
+                        newConnectionA = j;
+                    }
+
+                    if(P.get(j).contains(oldConnectionB)){
+                        newConnectionB = j;
                     }
                 }
             }
+
+            transitionTable[i][0] = newConnectionA;
+            transitionTable[i][1] = newConnectionB;
         }
 
         return transitionTable;