da sistemare Kosaraju

Algoritmi_2/Laboratorio/Lab5/Test/TestKosaraju.java

+import it.uniupo.graphLib.DirectedGraph;
+import it.uniupo.graphLib.UndirectedGraph;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public
+class TestKosaraju {
+
+    @Test
+    void testCostructor() {
+        DirectedGraph g = new DirectedGraph("3; 0 1; 0 2");
+        Kosaraju kosaraju = new Kosaraju(g);
+        Assertions.assertNotNull(kosaraju);
+    }
+
+    @Test
+    void testReversePostVisitOrder() {
+        DirectedGraph g = new DirectedGraph("5; 1 4; 4 3; 3 1; 1 2; 4 0; 2 0; 0 2;");
+        Kosaraju kosaraju = new Kosaraju(g);
+        ArrayList<Integer> reversePostVisitOrder = kosaraju.reversePostVisitOrder();
+        Assertions.assertTrue(reversePostVisitOrder.indexOf(1) < reversePostVisitOrder.indexOf(0) && reversePostVisitOrder.indexOf(1) < reversePostVisitOrder.indexOf(2));
+        Assertions.assertTrue(reversePostVisitOrder.indexOf(4) < reversePostVisitOrder.indexOf(0) && reversePostVisitOrder.indexOf(4) < reversePostVisitOrder.indexOf(2));
+        Assertions.assertTrue(reversePostVisitOrder.indexOf(3) < reversePostVisitOrder.indexOf(0) && reversePostVisitOrder.indexOf(3) < reversePostVisitOrder.indexOf(2));
+    }
+
+    @Test
+    void testGetSCC() {
+        DirectedGraph g = new DirectedGraph("5; 1 4; 4 3; 3 1; 1 2; 4 0; 2 0; 0 2;");
+        Kosaraju kosaraju = new Kosaraju(g);
+        System.out.println(Arrays.toString(kosaraju.getSCC()));
+    }
+}

Algoritmi_2/Laboratorio/Lab5/Test/TestLab.java

@@ -7,7 +7,8 @@ import org.junit.jupiter.api.Test;
 import java.util.ArrayList;
 import java.util.Arrays;
 
-public class TestLab {
+public
+class TestLab {
     @Test
     void testIsConnected() {
         UndirectedGraph gOneNode = new UndirectedGraph("1;");
@@ -62,8 +63,6 @@ public class TestLab {
 
         DirectedGraph gThreeNodes = new DirectedGraph("3; 2 0;");
         DFS dfsTest3 = new DFS(gThreeNodes);
-        System.out.println(dfsTest3.topologicalOrder());
-        ArrayList<Integer> topologicOrder = dfsTest3.topologicalOrder();
-        //DA FINIRE MA FUNZIONA
+        Assertions.assertTrue(dfsTest3.topologicalOrder().indexOf(2) < dfsTest3.topologicalOrder().indexOf(0));
     }
 }

Algoritmi_2/Laboratorio/Lab5/src/Kosaraju.java

+import it.uniupo.graphLib.DirectedGraph;
+import it.uniupo.graphLib.GraphInterface;
+import it.uniupo.graphLib.GraphUtils;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+
+public
+class Kosaraju {
+    private DirectedGraph myGraph;
+    private boolean[] founded;
+    private ArrayList<Integer> postVisitOrder = new ArrayList<>();
+
+    static private DirectedGraph reversedGraph;
+
+    Kosaraju(DirectedGraph g) {
+        this.myGraph = g;
+        founded = new boolean[myGraph.getOrder()];
+        reversedGraph = GraphUtils.reverseGraph(myGraph);
+    }
+
+    private
+    void visitaDFS(int sorg) {
+        founded[sorg] = true;
+        for (Integer neighbor : myGraph.getNeighbors(sorg)) {
+            if (!founded[neighbor]) {
+                visitaDFS(neighbor);
+            }
+        }
+        postVisitOrder.add(sorg);
+    }
+
+    public
+    ArrayList<Integer> reversePostVisitOrder() {
+        Arrays.fill(founded, false);
+        postVisitOrder.clear();
+        for (int node = 0; node < myGraph.getOrder(); node++) {
+            if (!founded[node]) {
+                visitaDFS(node);
+            }
+        }
+        ArrayList<Integer> reversePostVisitOrderArray = postVisitOrder;
+        Collections.reverse(reversePostVisitOrderArray);
+        return reversePostVisitOrderArray;
+    }
+
+    public
+    void getSCCImpl(int sorg, int cnt) {
+        founded[sorg] = true;
+        for (Integer neighbor : myGraph.getNeighbors(sorg)) {
+            if (!founded[neighbor]) {
+                getSCCImpl(neighbor, cnt);
+            }
+        }
+    }
+
+    public
+    int[] getSCC() {
+        int[] SCC = new int[myGraph.getOrder()];
+        int cnt = 0;
+        ArrayList<Integer> reversePostVisitOrderArray = reversePostVisitOrder();
+        Arrays.fill(founded, false);
+        for (Integer node : reversePostVisitOrderArray) {
+            postVisitOrder.clear(); //Uso l'array del OFV solo per sapere che nodi ho scoperto
+            if (!founded[node]) {
+                visitaDFS(node);
+                ArrayList<Integer> foundedNode = postVisitOrder;
+                for (int foundednode : foundedNode) {
+                    SCC[foundednode] = cnt;
+                }
+                cnt++;
+            }
+        }
+        return SCC;
+    }
+}