Revert "Replace Tarjan algorithm with slightly improved version" (tests are failing)

This reverts commit bf577d4

Author: easbar

core/src/main/java/com/graphhopper/routing/lm/LandmarkStorage.java

@@ -28,8 +28,7 @@
 import com.graphhopper.routing.SPTEntry;
 import com.graphhopper.routing.ev.BooleanEncodedValue;
 import com.graphhopper.routing.subnetwork.SubnetworkStorage;
-import com.graphhopper.routing.subnetwork.TarjanSCC;
-import com.graphhopper.routing.subnetwork.TarjanSCC.ConnectedComponents;
+import com.graphhopper.routing.subnetwork.TarjansSCCAlgorithm;
 import com.graphhopper.routing.util.AllEdgesIterator;
 import com.graphhopper.routing.util.EdgeFilter;
 import com.graphhopper.routing.util.FlagEncoder;
@@ -254,11 +253,11 @@ public void createLandmarks() {
 
         // we cannot reuse the components calculated in PrepareRoutingSubnetworks as the edgeIds changed in between (called graph.optimize)
         // also calculating subnetworks from scratch makes bigger problems when working with many oneways
-        TarjanSCC tarjan = new TarjanSCC(graph, encoder.getAccessEnc(), true);
-        tarjan.setAdditionalEdgeFilter(tarjanFilter);
-        ConnectedComponents graphComponents = tarjan.findComponents();
+        TarjansSCCAlgorithm tarjanAlgo = new TarjansSCCAlgorithm(graph, encoder.getAccessEnc(), true);
+        tarjanAlgo.setAdditionalEdgeFilter(tarjanFilter);
+        List<IntArrayList> graphComponents = tarjanAlgo.findComponents();
         if (logDetails)
-            LOGGER.info("Calculated " + graphComponents.getComponents().size() + " subnetworks via tarjan in " + sw.stop().getSeconds() + "s, " + Helper.getMemInfo());
+            LOGGER.info("Calculated " + graphComponents.size() + " subnetworks via tarjan in " + sw.stop().getSeconds() + "s, " + Helper.getMemInfo());
 
         EdgeExplorer tmpExplorer = graph.createEdgeExplorer(new RequireBothDirectionsEdgeFilter(encoder));
         String additionalInfo = "";
@@ -269,7 +268,7 @@ public void createLandmarks() {
             // see estimateMaxWeight. If we pick the distance too big for small areas this could lead to (slightly)
             // suboptimal routes as there will be too big rounding errors. But picking it too small is bad for performance
             // e.g. for Germany at least 1500km is very important otherwise speed is at least twice as slow e.g. for 1000km
-            double maxWeight = estimateMaxWeight(tmpExplorer, graphComponents.getComponents(), blockedEdges);
+            double maxWeight = estimateMaxWeight(tmpExplorer, graphComponents, blockedEdges);
             setMaximumWeight(maxWeight);
             additionalInfo = ", maxWeight:" + maxWeight + " from quick estimation";
         }
@@ -278,13 +277,13 @@ public void createLandmarks() {
             LOGGER.info("init landmarks for subnetworks with node count greater than " + minimumNodes + " with factor:" + factor + additionalInfo);
 
         int nodes = 0;
-        for (IntArrayList subnetworkIds : graphComponents.getComponents()) {
+        for (IntArrayList subnetworkIds : graphComponents) {
             nodes += subnetworkIds.size();
             if (subnetworkIds.size() < minimumNodes)
                 continue;
             if (factor <= 0)
                 throw new IllegalStateException("factor wasn't initialized " + factor + ", subnetworks:"
-                        + graphComponents.getComponents().size() + ", minimumNodes:" + minimumNodes + ", current size:" + subnetworkIds.size());
+                        + graphComponents.size() + ", minimumNodes:" + minimumNodes + ", current size:" + subnetworkIds.size());
 
             int index = subnetworkIds.size() - 1;
             // ensure start node is reachable from both sides and no subnetwork is associated

core/src/main/java/com/graphhopper/routing/subnetwork/PrepareRoutingSubnetworks.java

@@ -17,7 +17,6 @@
  */
 package com.graphhopper.routing.subnetwork;
 
-import com.carrotsearch.hppc.BitSet;
 import com.carrotsearch.hppc.IntArrayList;
 import com.carrotsearch.hppc.IntIndexedContainer;
 import com.graphhopper.routing.ev.BooleanEncodedValue;
@@ -106,22 +105,37 @@ public int getMaxSubnetworks() {
     int removeSmallSubNetworks(BooleanEncodedValue accessEnc) {
         // partition graph into strongly connected components using Tarjan's algorithm
         StopWatch sw = new StopWatch().start();
-        TarjanSCC tarjan = new TarjanSCC(ghStorage, accessEnc, false);
-        TarjanSCC.ConnectedComponents ccs = tarjan.findComponents();
-        List<IntArrayList> components = ccs.getComponents();
-        BitSet singleNodeComponents = ccs.getSingleNodeComponents();
-        logger.info("Found " + ccs.getTotalComponents() + " subnetworks (" + singleNodeComponents.cardinality() + " single nodes and "
-                + components.size() + " components with more than one node, total nodes: " + ccs.getNodes() + "), took: " + sw.stop().getSeconds() + "s");
+        TarjansSCCAlgorithm tarjan = new TarjansSCCAlgorithm(ghStorage, accessEnc, false);
+        List<IntArrayList> components = tarjan.findComponents();
+        int totalNodes = 0;
+        int singleNodeComponents = 0;
+        for (IntArrayList c : components) {
+            totalNodes += c.size();
+            if (c.size() == 1)
+                singleNodeComponents++;
+        }
+        logger.info("Found " + components.size() + " subnetworks (" + singleNodeComponents + " single nodes and "
+                + (components.size() - singleNodeComponents) + " components with more than one node, total nodes: " + totalNodes + "), took: " + sw.stop().getSeconds() + "s");
+
+        sw = new StopWatch().start();
+        // find the biggest component
+        IntArrayList biggest = components.isEmpty() ? new IntArrayList(0) : components.get(0);
+        for (IntArrayList component : components) {
+            if (component.size() > biggest.size()) {
+                biggest = component;
+            }
+        }
+        logger.info("finding the biggest component took: " + sw.stop().getSeconds() + "s");
 
         // remove all small networks except the biggest (even when its smaller than the given min_network_size)
         sw = new StopWatch().start();
         int removedComponents = 0;
         int removedEdges = 0;
-        int smallestRemaining = ccs.getBiggestComponent().size();
+        int smallestRemaining = biggest.size();
         int biggestRemoved = 0;
         EdgeExplorer explorer = ghStorage.createEdgeExplorer(DefaultEdgeFilter.allEdges(accessEnc));
         for (IntArrayList component : components) {
-            if (component == ccs.getBiggestComponent())
+            if (component == biggest)
                 continue;
 
             if (component.size() < minNetworkSize) {
@@ -138,9 +152,9 @@ int removeSmallSubNetworks(BooleanEncodedValue accessEnc) {
             throw new IllegalStateException("Too many total edges were removed: " + removedEdges + " out of " + ghStorage.getEdges() + "\n" +
                     "The maximum number of removed edges is: " + allowedRemoved);
 
-        subnetworks = ccs.getTotalComponents() - removedComponents;
+        subnetworks = components.size() - removedComponents;
         logger.info("Removed " + removedComponents + " subnetworks (biggest removed: " + biggestRemoved + " nodes) -> " +
-                subnetworks + " subnetwork(s) left (smallest: " + smallestRemaining + ", biggest: " + ccs.getBiggestComponent().size() + " nodes)"
+                subnetworks + " subnetwork(s) left (smallest: " + smallestRemaining + ", biggest: " + biggest.size() + " nodes)"
                 + ", total removed edges: " + removedEdges + ", took: " + sw.stop().getSeconds() + "s");
         return removedEdges;
     }