v1.0.7

Author: RyanAlbertson

.idea/workspace.xml

@@ -34,8 +34,7 @@ of nodes that starts from the source and ends at the target. The nodes in the pa
 edges each have a respective weight. The shortest path will be the path of nodes between the source and target that 
 minimizes the total weight of all edges connecting those path nodes.
 
-> Example:
-Let our graph have nodes that represent US cities. The edges between those nodes are select roads that travel 
+> Let our graph have nodes that represent US cities. The edges between those nodes are select roads that travel 
 between the cities. Each road has an associated distance, this is the edge weight. Let's say our source node is 
 Boston and our target node is Dallas. We want the shortest path between the two cities, given our graph of cities 
 and roads. Such a path will indeed span between the two cities, but it will also be the least distance out of all 
@@ -59,8 +58,7 @@ subgraph of some parent graph such that:
 
 Considering all this, a minimum spanning tree is just a tree that minimizes the total edge weights within it.
 
->Example:
-Using the cities and roads analogy, a MST would be a collection of roads that together connect every city and the 
+> Using the cities and roads analogy, a MST would be a collection of roads that together connect every city and the 
 sum of distances of these roads is the least possible such that all cities are still linked together with this network 
 of roads.
 
@@ -89,6 +87,7 @@ The application is launched by executing _Algorithm.Visualizer.exe_
   - Dijkstra's Algorithm
   - A* Search
   - Bellman-Ford
+  - Floyd-Warshall
   - Reverse Delete
   - Kruskal's Algorithm
   - Prim's Algorithm
@@ -119,6 +118,9 @@ The application is launched by executing _Algorithm.Visualizer.exe_
 > Fast Bellman-Ford algorithm on a medium graph
 > <img src="./media/bellman_ford.gif" width=800>
 
+> Fast Floyd-Warshall algorithm on a small graph
+> <img src="./media/floyd_warshall.gif" width=800>
+
 > Fast Kruskal's algorithm on a large graph
 > <img src="./media/kruskal.gif" width=800>
 

Algorithm Visualizer.exe

@@ -38,6 +38,7 @@ public GUI() {
         initMenuPanel();
         frame.pack();
         frame.setVisible(true);
+        frame.setResizable(false);
     }
 
 
@@ -119,7 +120,7 @@ private void initMenuPanel() {
         chooseAlgName = new JComboBox<>();
         Defs.algNames.forEach(chooseAlgName::addItem);
         // Default. See GraphPanel constuctor
-        chooseAlgName.setSelectedItem("Dijkstra");
+        chooseAlgName.setSelectedItem("A*");
         chooseAlgName.setFont(new Font("Ariel", Font.PLAIN, 18));
         chooseAlgName.addActionListener(event -> chooseAlgNameActions());
         menu.add(chooseAlgName);

README.md

@@ -65,12 +65,13 @@ public MOUSE_STATE next() {
     public GraphPanel() {
 
         // Defaults
-        algName = "Dijkstra";
+        algName = "A*";
         speed = Defs.speedST.get("Fast");
         graphSize = "Large";
         isShortPathAlg = Defs.isShortPathAlg.get(algName);
         nodeCount = Defs.nodeCountST.get(graphSize);
         visitedEdges = ConcurrentHashMap.newKeySet();
+        path = new int[nodeCount];
 
         GraphGenerator.generateGraph(this);
         mouseState = MOUSE_STATE.SOURCE_NODE;
@@ -83,7 +84,6 @@ public GraphPanel() {
 
             @Override
             public void mouseClicked(MouseEvent me) {
-
                 super.mouseClicked(me);
 
                 // Block node selection during animation
@@ -129,7 +129,7 @@ protected void paintComponent(Graphics g) {
         g2D.setRenderingHint(RenderingHints.KEY_RENDERING,
                 RenderingHints.VALUE_RENDER_QUALITY);
         g2D.setFont(new Font("Ariel", Font.PLAIN, 18));
-        if (isShortPathAlg) {
+        if (isShortPathAlg && null != algorithm && !algorithm.isAlive()) {
             g2D.drawString("Click nodes to define a source and target",
                     (float) (GUI.WINDOW_WIDTH * 0.39), 15);
             g2D.setFont(new Font("Ariel", Font.PLAIN, 16));
@@ -183,6 +183,7 @@ protected void paintComponent(Graphics g) {
             g2D.setStroke(new BasicStroke(4f));
             int currentNode = targetNode;
             int prevNode = path[targetNode];
+            // Tranverse path back to source node
             while (prevNode != Integer.MAX_VALUE) {
                 double currentNodeX = nodeCoords.get(currentNode)[0];
                 double currentNodeY = nodeCoords.get(currentNode)[1];
@@ -191,8 +192,6 @@ protected void paintComponent(Graphics g) {
                 g2D.draw(new Line2D.Double(currentNodeX, currentNodeY,
                         prevNodeX, prevNodeY));
                 g2D.fill(nodeShapes.get(prevNode));
-
-                // Tranverse path back to source node
                 currentNode = prevNode;
                 prevNode = path[prevNode];
             }
@@ -228,7 +227,7 @@ public void resetAnimation() {
 
 
     /**
-     * If an algorithm is running, it is unpaused. Otherwise, a new process
+     * If an algorithm is running, then it is unpaused. Otherwise, a new process
      * of the currently selected algorithm is started.
      */
     protected void startAlgorithm() {
@@ -253,6 +252,9 @@ protected void startAlgorithm() {
                 case "Bellman-Ford":
                     algorithm = new BellmanFord(this);
                     break;
+                case "Floyd-Warshall":
+                    algorithm = new FloydWarshall(this);
+                    break;
                 case "Reverse Delete":
                     algorithm = new ReverseDelete(this);
                     break;

media/floyd_warshall.gif

@@ -12,7 +12,7 @@ public class Defs {
     // All algorithms available with the visualizer
     public static final List<String> algNames = List.of("Depth-First Search",
             "Breadth-First Search", "Dijkstra", "A*", "Bellman-Ford",
-            "Reverse Delete", "Kruskal", "Prim");
+            "Floyd-Warshall", "Reverse Delete", "Kruskal", "Prim");
 
     // Maps algorithms to whether they should use minimum connected graphs or not.
     public static final Map<String, Boolean> isShortPathAlg =
@@ -22,6 +22,7 @@ public class Defs {
                     Map.entry("Dijkstra", true),
                     Map.entry("A*", true),
                     Map.entry("Bellman-Ford", true),
+                    Map.entry("Floyd-Warshall", true),
                     Map.entry("Reverse Delete", false),
                     Map.entry("Kruskal", false),
                     Map.entry("Prim", false)));

src/Algorithm_Visualizer.jar

@@ -0,0 +1,145 @@
+package main.java.util.algorithms;
+
+
+import main.java.GraphPanel;
+import org.jgrapht.graph.DefaultWeightedEdge;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Implements a Floyd-Warshall algorithm to find a shortest path from a
+ * {@link GraphPanel#sourceNode} to a {@link  GraphPanel#targetNode}.
+ *
+ * @author Ryan Albertson
+ */
+public class FloydWarshall extends Algorithm {
+    
+
+    /**
+     * Constructor.
+     * @param gPanel {@link GraphPanel}.
+     */
+    public FloydWarshall(GraphPanel gPanel) {
+
+        super(gPanel);
+    }
+
+
+    /**
+     * @param skip The animation pause will be effectively removed if skip is true.
+     * @see Algorithm#animate()
+     */
+    protected void animate(boolean skip) {
+
+        int speed = gPanel.speed > 0 ? gPanel.speed - 350 : gPanel.speed;
+        if (skip) speed = 0;
+        try {
+            // Update animation
+            gPanel.repaint();
+            TimeUnit.MILLISECONDS.sleep(speed);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        checkForPause();
+    }
+
+
+    public void runAlgorithm(Integer node) {
+
+        // distanceTo[i][j] is the min weight path from node i to node j
+        double[][] distanceTo = new double[gPanel.nodeCount][gPanel.nodeCount];
+        for (double[] row : distanceTo) Arrays.fill(row, Double.MAX_VALUE);
+
+        // Pointers to next nodes in paths within the graph
+        int[][] next = new int[gPanel.nodeCount][gPanel.nodeCount];
+        for (int[] row : next) Arrays.fill(row, -1);
+
+        // Init the weights of direct edges between node pairs
+        for (DefaultWeightedEdge edge : gPanel.graph.edgeSet()) {
+            int edgeSource = gPanel.graph.getEdgeSource(edge);
+            int edgeTarget = gPanel.graph.getEdgeTarget(edge);
+
+            distanceTo[edgeSource][edgeTarget] = gPanel.graph.getEdgeWeight(edge);
+            next[edgeSource][edgeTarget] = edgeTarget;
+            // Consider the other direction of current edge
+            distanceTo[edgeTarget][edgeSource] = distanceTo[edgeSource][edgeTarget];
+            next[edgeTarget][edgeSource] = edgeSource;
+        }
+
+        // For every node in the graph, iterate through every pair of nodes
+        for (int k = 0; k < gPanel.nodeCount; k++) {
+            // Check if we can reroute path i~j through node k
+            for (int i = 0; i < gPanel.nodeCount; i++) {
+                for (int j = 0; j < gPanel.nodeCount; j++) {
+                    // Bypass animation pause if no updates were made
+                    boolean skipAnimation = true;
+                    // Update distance if shorter path is found between i~j
+                    if (distanceTo[i][k] + distanceTo[k][j] < distanceTo[i][j]) {
+                        distanceTo[i][j] = distanceTo[i][k] + distanceTo[k][j];
+                        // Update pointer for this path
+                        next[i][j] = next[i][k];
+
+                        DefaultWeightedEdge edge = gPanel.graph.getEdge(i, k);
+                        if (null == edge) edge = gPanel.graph.getEdge(k, i);
+                        if (null != edge) {
+                            gPanel.visitedEdges.add(edge);
+                            skipAnimation = false;
+                        }
+                        edge = gPanel.graph.getEdge(k, j);
+                        if (null == edge) edge = gPanel.graph.getEdge(j, k);
+                        if (null != edge) {
+                            gPanel.visitedEdges.add(edge);
+                            skipAnimation = false;
+                        }
+                    } else {
+                        DefaultWeightedEdge edge = gPanel.graph.getEdge(i, j);
+                        if (null == edge) edge = gPanel.graph.getEdge(j, i);
+                        if (null != edge) {
+                            gPanel.visitedEdges.add(edge);
+                            skipAnimation = false;
+                        }
+                    }
+                    // Check if user has stopped or paused algorithm
+                    animate(skipAnimation);
+                    if (isStopped()) return;
+                }
+            }
+            gPanel.visitedEdges.clear();
+
+            int u = gPanel.sourceNode;
+            int v = gPanel.targetNode;
+            // If path exists
+            if (next[u][v] != -1) {
+                // Build path and then trace in reverse order for animation
+                List<Integer> path = new LinkedList<>();
+                path.add(u);
+                while (u != v) {
+                    u = next[u][v];
+                    path.add(u);
+                }
+                ListIterator<Integer> it = path.listIterator(path.size());
+                Integer curr = path.get(path.size() - 1);
+                while (it.hasPrevious() && !curr.equals(gPanel.sourceNode)) {
+                    int prev = it.previous();
+                    gPanel.path[curr] = prev;
+                    curr = prev;
+                }
+
+                // Check if user has stopped or paused algorithm
+                animate(true);
+                if (isStopped()) return;
+            }
+        }
+    }
+
+
+    public void runAlgorithm() {
+
+        // This signature isn't needed for this algorithm.
+    }
+}