add findCentroid recursive method, add tests for building CTree

Author: lennart

src/main/java/com/thealgorithms/tree/CentroidDecomposition.java

@@ -3,65 +3,109 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
-import java.util.HashMap;
 
 public class CentroidDecomposition {
     private List<Integer>[] tree;
     private List<Integer>[] centroidTree;
-    private boolean[] removedCentroids;
+    private boolean[] centroidMarked;
+    private int[] centroidParent;
+    private int startingNode;
+    private int N;
 
+    public CentroidDecomposition(int n, int startingNode){
+        tree = new ArrayList[n];
+        centroidTree = new ArrayList[n];
+        N = n;
+        for (int i = 0; i < centroidTree.length; i++) centroidTree[i] = new ArrayList<>();
+        for (int i = 0; i < tree.length; i++) tree[i] = new ArrayList<>();
+        centroidMarked = new boolean[n];
+        centroidParent = new int[n];
+        startingNode = (int)(Math.random() * n+1);
+        for(int i = 0; i<n; i++){
+            tree[i] = new ArrayList<>();
+        }
+    }
     public CentroidDecomposition(int n){
         tree = new ArrayList[n];
         centroidTree = new ArrayList[n];
-        removedCentroids = new boolean[n];
+        centroidMarked = new boolean[n];
+        centroidParent = new int[n];
+        startingNode = (this.startingNode == -1) ? (int)(Math.random() * n+1) : this.startingNode;
+        N = n;
+        for (int i = 0; i < centroidTree.length; i++) centroidTree[i] = new ArrayList<>();
+        for (int i = 0; i < tree.length; i++) tree[i] = new ArrayList<>();
         for(int i = 0; i<n; i++){
             tree[i] = new ArrayList<>();
         }
     }
 
+    public List<Integer>[] getCentroidTree(){
+        return centroidTree;
+    }
+
     public void addEdge(int u, int v){
         tree[u].add(v);
         tree[v].add(u);
     }
 
+    private void addEdgeCTree(int u, int v){
+        centroidTree[u].add(v);
+        centroidTree[v].add(u);
+        centroidParent[v] = u;
+    }
+
+
     public void findSubtreeSizes(int src, boolean[] visited, int[] subtreeSizes){
         // dfs traversal to find size of subtree rooted at src
         visited[src] = true;
         subtreeSizes[src] = 1;
         for (int node : tree[src]){
-            if(!visited[node]){
+            if(!visited[node] && !centroidMarked[node]){
                 visited[node] = true;
                 findSubtreeSizes(node, visited, subtreeSizes); // recurse down to last child node
                 subtreeSizes[src] += subtreeSizes[node]; // add size of full recursive path to subtree Size of src
             }
         }
     }
 
-    private void findCentroid(int src){
-        int treeSize = tree[src].size();
-        int[] subtreeSizes = new int[treeSize];
-        boolean[] visited = new boolean[treeSize];
+    public void findCentroid(int src, int previousCentroid){
+        int[] subtreeSizes = new int[N];
+        boolean[] visited = new boolean[N];
         Arrays.fill(visited, false);
-
+        
         findSubtreeSizes(src, visited, subtreeSizes);
+        int treeSize = Arrays.stream(subtreeSizes).max().getAsInt();
+
+        centroidMarked[src] = true;
 
-        boolean isCentroid = true;
         for (int node : tree[src]){
-            isCentroid = (subtreeSizes[node] <= (subtreeSizes[src]/2)) ? true : false;
+            if (subtreeSizes[node] > (treeSize/2)){
+                centroidMarked[src] = false;
+                break;
+            }
         }
-
-        if (isCentroid){
+        
+        if (centroidMarked[src]){
+            if (src != startingNode && src != previousCentroid) addEdgeCTree(previousCentroid, src); 
+            // centroidTree[previousCentroid].add(src);
             for (int node : tree[src]){
-                
+                if (!centroidMarked[node])
+                    findCentroid(node, src);                
             }
         }
         else{
-            // pick one of the children of the node for next check
+            // pick one of the children of the root for next check
+            int nextLargestSubtree = tree[src].getFirst();
+            for (int node : tree[src]){
+                if (subtreeSizes[node] >= subtreeSizes[nextLargestSubtree]) 
+                    nextLargestSubtree = node;
+            }
+            findCentroid(nextLargestSubtree, previousCentroid);
         }
     }
 
     public static void main(String[] args) {
-        CentroidDecomposition cd = new CentroidDecomposition(16);
+        CentroidDecomposition cd = new CentroidDecomposition(16, -1);
         cd.addEdge(0, 1);
         cd.addEdge(0, 2);
         cd.addEdge(0, 3);
@@ -81,7 +125,22 @@ public static void main(String[] args) {
         boolean[] visited = new boolean[16];
         int[] subtreeSizes = new int[16];
 
-        cd.findSubtreeSizes(3, visited, subtreeSizes);
+        // int start = cd.startingNode;
+        int src = (int) ((Math.random() * (15)) + 0);
+        System.out.println("src= " + src);
+
+        cd.findCentroid(src, src);
+
+        // System.out.println((int)(Math.random() * 16));
+
+        for (int i = 0; i < cd.centroidTree.length; i++) {
+            System.out.println(String.format("%s %s", i, cd.centroidTree[i]));
+        }
+
+        // cd.findSubtreeSizes(8, visited, subtreeSizes);
+        // for (int i = 0; i < subtreeSizes.length; i++) {
+        //     System.out.println(String.format("%s %s", i, subtreeSizes[i]));
+        // }
     }
 
 }

src/test/java/com/thealgorithms/tree/CentroidDecompositionTest.java

@@ -1,16 +1,21 @@
 package com.thealgorithms.tree;
 
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Answers.values;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.RepeatedTest;
 import org.junit.jupiter.api.Test;
 
 class CentroidDecompositionTest {
     private CentroidDecomposition cd;
+    private int n = 16;
 
     @BeforeEach
     void setUp(){
@@ -45,20 +50,45 @@ void setUp(){
                          14
                           \
                            15
+
+
+
+                    0
+             /      |       \
+            1      11        8
+          /   \   / | \     / | \
+         4     5 2 12 14   3  9 10
+                / \    / \
+               7   6  15 13
    
          */
     }
 
     @Test
     void testFindSubtreeSizes(){
-        boolean[] visited = new boolean[16];
-        int[] subtreeSizes = new int[16];
+        boolean[] visited = new boolean[n];
+        int[] subtreeSizes = new int[n];
 
         cd.findSubtreeSizes(3, visited, subtreeSizes);
         assertEquals(subtreeSizes[8], 3);
         assertEquals(subtreeSizes[0], 12);
     }
 
+    @RepeatedTest(100)
+    void testBuildCentroidTree(){
+        int src = (int) ((Math.random() * (15)) + 0);
+        cd.findCentroid(src, src);
+        List<Integer>[] centroidTree = cd.getCentroidTree();
+        
+        List<Integer> correct = new ArrayList<Integer>();
+        correct.add(0);
+        correct.add(3);
+        correct.add(9);
+        correct.add(10);
 
+        for (int j = 0; j < centroidTree[8].size(); j++) {
+            assertEquals(correct.get(j), centroidTree[8].get(j));
+        }
 
+    }
 }