BAEL-3883: Boruvka's minimum spanning tree, moved code to newer module (#8949)

algorithms-miscellaneous-6
2020-03-24 08:37:48 +05:30
parent 1062b4fef6
commit 060557608c
12 changed files with 172 additions and 396 deletions
@@ -0,0 +1,84 @@
+package com.baeldung.algorithms.boruvka;
+
+import com.google.common.graph.EndpointPair;
+import com.google.common.graph.MutableValueGraph;
+import com.google.common.graph.ValueGraphBuilder;
+
+public class BoruvkaMST {
+
+    private static MutableValueGraph<Integer, Integer> mst = ValueGraphBuilder.undirected()
+        .build();
+    private static int totalWeight;
+
+    public BoruvkaMST(MutableValueGraph<Integer, Integer> graph) {
+
+        int size = graph.nodes().size();
+
+        UnionFind uf = new UnionFind(size);
+
+        // repeat at most log N times or until we have N-1 edges
+        for (int t = 1; t < size && mst.edges().size() < size - 1; t = t + t) {
+            
+            EndpointPair<Integer>[] closestEdgeArray = new EndpointPair[size];
+
+            // foreach tree in graph, find closest edge
+            for (EndpointPair<Integer> edge : graph.edges()) {
+                int u = edge.nodeU();
+                int v = edge.nodeV();
+                int uParent = uf.find(u);
+                int vParent = uf.find(v);
+                if (uParent == vParent) {
+                    continue; // same tree
+                }
+
+                int weight = graph.edgeValueOrDefault(u, v, 0);
+
+                if (closestEdgeArray[uParent] == null) {
+                    closestEdgeArray[uParent] = edge;
+                }
+                if (closestEdgeArray[vParent] == null) {
+                    closestEdgeArray[vParent] = edge;
+                }
+
+                int uParentWeight = graph.edgeValueOrDefault(closestEdgeArray[uParent].nodeU(), closestEdgeArray[uParent].nodeV(), 0);
+                int vParentWeight = graph.edgeValueOrDefault(closestEdgeArray[vParent].nodeU(), closestEdgeArray[vParent].nodeV(), 0);
+
+                if (weight < uParentWeight) {
+                    closestEdgeArray[uParent] = edge;
+                }
+                if (weight < vParentWeight) {
+                    closestEdgeArray[vParent] = edge;
+                }
+            }
+
+            // add newly discovered edges to MST
+            for (int i = 0; i < size; i++) {
+                EndpointPair<Integer> edge = closestEdgeArray[i];
+                if (edge != null) {
+                    int u = edge.nodeU();
+                    int v = edge.nodeV();
+                    int weight = graph.edgeValueOrDefault(u, v, 0);
+                    // don't add the same edge twice
+                    if (uf.find(u) != uf.find(v)) {
+                        mst.putEdgeValue(u, v, weight);
+                        totalWeight += weight;
+                        uf.union(u, v);
+                    }
+                }
+            }
+        }
+    }
+
+    public MutableValueGraph<Integer, Integer> getMST() {
+        return mst;
+    }
+
+    public int getTotalWeight() {
+        return totalWeight;
+    }
+
+    public String toString() {
+        return "MST: " + mst.toString() + " | Total Weight: " + totalWeight;
+    }
+
+}
@@ -0,0 +1,39 @@
+package com.baeldung.algorithms.boruvka;
+
+public class UnionFind {
+    private int[] parents;
+    private int[] ranks;
+
+    public UnionFind(int n) {
+        parents = new int[n];
+        ranks = new int[n];
+        for (int i = 0; i < n; i++) {
+            parents[i] = i;
+            ranks[i] = 0;
+        }
+    }
+
+    public int find(int u) {
+        while (u != parents[u]) {
+            u = parents[u];
+        }
+        return u;
+    }
+
+    public void union(int u, int v) {
+        int uParent = find(u);
+        int vParent = find(v);
+        if (uParent == vParent) {
+            return;
+        }
+
+        if (ranks[uParent] < ranks[vParent]) {
+            parents[uParent] = vParent;
+        } else if (ranks[uParent] > ranks[vParent]) {
+            parents[vParent] = uParent;
+        } else {
+            parents[vParent] = uParent;
+            ranks[uParent]++;
+        }
+    }
+}