Add subtour constraint as Gurobi lazy constraint

Author: Plastix

src/main/java/io/github/plastix/GraphUtils.java

@@ -1,7 +1,9 @@
 package io.github.plastix;
 
+import com.graphhopper.routing.util.DefaultEdgeFilter;
 import com.graphhopper.routing.util.FlagEncoder;
 import com.graphhopper.storage.Graph;
+import com.graphhopper.util.EdgeExplorer;
 import com.graphhopper.util.EdgeIterator;
 
 public class GraphUtils {
@@ -30,4 +32,8 @@ public boolean isOneWay(EdgeIterator edgeIterator) {
         return edgeIterator.isForward(flagEncoder) != edgeIterator.isBackward(flagEncoder);
     }
 
+    public EdgeExplorer getEdgeExplorer() {
+        return graph.createEdgeExplorer(new DefaultEdgeFilter(flagEncoder));
+    }
+
 }

src/main/java/io/github/plastix/Main.java

@@ -104,6 +104,10 @@ private static void setupSolver() throws GRBException {
         GRBVar startNode = vars.getVertex(START_NODE_ID);
         startNode.set(GRB.DoubleAttr.LB, 1);
         startNode.set(GRB.DoubleAttr.UB, 1);
+
+        // Must set LazyConstraints parameter when using lazy constraints
+        model.set(GRB.IntParam.LazyConstraints, 1);
+        model.setCallback(new SubtourConstraint(vars, START_NODE_ID, graphUtils));
     }
 
     private static void runSolver() throws GRBException {

src/main/java/io/github/plastix/SubtourConstraint.java

@@ -0,0 +1,103 @@
+package io.github.plastix;
+
+import com.carrotsearch.hppc.IntArrayDeque;
+import com.carrotsearch.hppc.IntHashSet;
+import com.carrotsearch.hppc.cursors.IntCursor;
+import com.graphhopper.util.EdgeExplorer;
+import com.graphhopper.util.EdgeIterator;
+import gurobi.GRB;
+import gurobi.GRBCallback;
+import gurobi.GRBException;
+import gurobi.GRBLinExpr;
+
+public class SubtourConstraint extends GRBCallback {
+
+    private final int START_NODE_ID;
+    private GraphUtils graphUtils;
+    private Vars vars;
+
+    SubtourConstraint(Vars vars, int startNodeId, GraphUtils graphUtils) {
+        this.vars = vars;
+        this.START_NODE_ID = startNodeId;
+        this.graphUtils = graphUtils;
+    }
+
+    @Override
+    protected void callback() {
+        try {
+            if(where == GRB.CB_MIPSOL) { // Found an integer feasible solution
+
+                IntHashSet vertices = getReachableVertexSubset(START_NODE_ID);
+                int verticesVisited = numVisitedVertices();
+
+                // If the number of vertices we can reach from the start is not the number of vertices we
+                // visit in the entire solution, we have a disconnected tour
+                if(vertices.size() < verticesVisited) {
+                    vertices.remove(START_NODE_ID);
+
+                    // Add sub-tour elimination constraint
+                    GRBLinExpr subtourConstraint = new GRBLinExpr();
+                    int sumVertexVisits = 0;
+                    int totalOutgoingEdges = 0;
+
+                    for(IntCursor cursor : vertices) {
+                        int vertexId = cursor.value;
+                        EdgeIterator outgoing = graphUtils.outgoingEdges(vertexId);
+
+                        while(outgoing.next()) {
+                            subtourConstraint.addTerm(1, vars.getArc(outgoing));
+                            totalOutgoingEdges += 1;
+                        }
+
+                        sumVertexVisits += getSolution(vars.getVertex(vertexId));
+                    }
+
+                    double rhs = ((double) sumVertexVisits) / ((double) totalOutgoingEdges);
+                    addLazy(subtourConstraint, GRB.GREATER_EQUAL, rhs);
+
+                }
+            }
+        } catch(GRBException e) {
+            System.out.println("Error code: " + e.getErrorCode() + ". " +
+                    e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    private int numVisitedVertices() throws GRBException {
+        double[] values = getSolution(vars.getVerts());
+
+        int visited = 0;
+        for(double value : values) {
+            if(value > 0) {
+                visited++;
+            }
+        }
+
+        return visited;
+    }
+
+    private IntHashSet getReachableVertexSubset(int startNode) throws GRBException {
+        EdgeExplorer explorer = graphUtils.getEdgeExplorer();
+        IntArrayDeque stack = new IntArrayDeque();
+        stack.addLast(startNode);
+
+        IntHashSet explored = new IntHashSet();
+        int current;
+        while(stack.size() > 0) {
+            current = stack.removeLast();
+            if(!explored.contains(current)) {
+                EdgeIterator iter = explorer.setBaseNode(current);
+                while(iter.next()) {
+                    int connectedId = iter.getAdjNode();
+                    if(getSolution(vars.getArc(iter)) > 0) {
+                        stack.addLast(connectedId);
+                    }
+                }
+                explored.add(current);
+            }
+        }
+
+        return explored;
+    }
+}

src/main/java/io/github/plastix/Vars.java

@@ -86,4 +86,7 @@ public GRBVar getVertex(int id) {
         return verts[id];
     }
 
+    public GRBVar[] getVerts() {
+        return verts;
+    }
 }