Ecología industrial

To rank symmetric TSP solutions in order of non-decreasing TSP value, we adopted the basic version of the enumeration procedure described by Lawler [168], which ranks the feasible solutions of a discrete binary optimization problem according to their objective function values. Such iterative method consists of a branching strategy in the solution space. Every node is a subproblem of the original problem, in the sense that it is generated from binary impositions on a subset of the variables. At each iteration k, the branching rule has the effect of excluding the k-th best solution from further consideration.

The ranking of TSP solutions according to the Lawler’s procedure requires to have an efficient method for solving TSP subproblems.

Since we wanted to solve instances with up to 20 targets, we used as a black-box the enumeration code with pruning in Chapter 1 of Applegate et al. [9], denoted as ACDJ code in the following. In ACDJ code, the TSP solution space is represented as a tree of partial permutations in which the level of a node is the number of vertices included in the permutation; while at the root node no vertex is selected, the leaf nodes correspond to complete tours. Given a cost matrix, the algorithm computes an upper bound on the TSP optimal value with a nearest-neighborhood algorithm (see, e.g., a recent paper by Hurkens and Woeginger [144]) and then explores the space of permutations on TSP nodes with the aim of determining a minimum-cost one. A speed-up of the computational time is obtained by pruning nodes according to bounding rules. The method implemented for pruning is to compute a lower bound on the completion of the partial tour at the current node: if the sum of the partial cost and of the lower bound exceeds the best known upper bound on the optimal value, then the current

node is fathomed. The lower bound chosen by the authors is the well-known minimum spanning tree bound (Held and Karp [132]).

The Traveling Salesman Problem can be modeled as a discrete optimization problem where integer variables are the binary arc variables (Dantzig et al. [73]). We simulated the fixing of TSP binary variables by modifying the edge Euclidean costs appropri- ately: forbidding edge (i, j) in the solution is equivalent to change its original cost cij

to a considerably high cost C (e.g., 2, 000 times the maximum cost edge); analogously, including (i, j) in the solution is obtained by setting cij = −C.

In addition, whenever a vertex i is connected with two vertices k1, k2 due to the edge

impositions, we forbid edges (i, j) with j 6= k1, k2. Within these settings, an infeasible

TSP subproblem is associated with tours with at least one edge having cost C. Since the ACDJ code is not naturally able to recognize the possible infeasibility of a TSP subproblem, the feasibility of the minimum-cost permutation obtained will be deter- mined by the absence of edges with cost C. Our computational experience shows that the time required to run ACDJ algorithm on infeasible subproblems can be several orders of magnitude larger than that required to solve feasible ones. This motivated us to apply techniques for detecting the infeasibility of symmetric TSP subproblems before calling the ACDJ code.

2.3.2.1 Detecting the Infeasibility of a Symmetric TSP Subproblem

As stated in Section 2.3.2, a method for speeding up the time required for the master problems of our BEA is to efficiently detect if a symmetric TSP subproblem is infea- sible or not. The question can be formulated on a graph as follows.

Problem 1. Given a sparse graph G = (V, E) and a subset E0 ⊂ E, determine if a Hamiltonian circuit including all edges in E0 exists in G.

The missing edges in graph G represent the edges forbidden in the subproblem. The edges in set E0 are instead the edges included in the solution. We implemented three different algorithms to address Problem 1. The methods, called V1, V2 and V3, differ in the increasing aggressiveness in the detection of infeasibilities. Only method V3 is able to prune all infeasible subproblems, so the other versions check for the presence of an edge with cost C in the minimum-cost permutation given by the ACDJ code. The code versions V1 and V2 implement two algorithms for inspecting the graph G of the current subproblem, after its edge costs matrix has been generated according to Lawler’s procedure.

The first check performed (version V1) is searching in G for vertices of degree greater than 2 with respect to edges in E0. Clearly, such situation violates the degree con- straints on TSP nodes and therefore the subproblem is infeasible.

After this check, the second version V2 investigates the presence of subtours using a Depth-First Search (DFS) algorithm (Tarjan [235]). In graphs in which every node is connected to at most two vertices, the connected components of the graph are disjoint paths. The depth-first exploration will find a subtour in the graph if there exists a connected component which is a circuit.

In version V3, the remaining infeasible subproblems are detected by using Constraint Programming (CP) techniques.

After checking the degree condition of version V1, version V3 invokes the M akeCircuit constraint of the software suite or-tools of [122]. Given a set of variables with fi- nite domain, the M akeCircuit function determines the presence of complete Hamilto- nian paths on the variable set by using filtering algorithms for the Circuit constraint (Benchimol et al. [33], Kaya and Hooker [156]). Note that in the CP setting, the value of a variable is its successor node in the Hamiltonian path: since subproblem graph G is not oriented, the setting of the CP problem equivalent to solve Problem 1 in G is not straightforward. After determining the TSP subproblem according to Lawler’s branching rules and checked the degree condition, the following CP model is solved in feasibility version. The set of variables is given by the set {1, . . . , n} ∪ {po = pf} plus

convenient auxiliary vertices. The domain D(i) of variable i is determined according to its degree with respect to edge set E0 in graph G. Namely,

• If degree of i is 0, then D(i) = {j ∈ V : (i, j) ∈ E}.

• If degree of i is 1, then two situations are considered. Let k = {j ∈ V : (i, j) ∈ E0}.

– If edge (i, k) is a connected component of the subgraph (V, E0) (i.e., the degree of k is 1), then

D(i) = {j ∈ V : (i, j) ∈ E} ∪ {ik},

D(k) = {j ∈ V : (k, j) ∈ E} ∪ {ik},

with ik /∈ V auxiliary vertex, D(ik) = {i, k}.

– If edge (i, k) is not a connected component of the subgraph (V, E0), then D(i) = {k} ∪ {j ∈ V : (i, j) ∈ E}.

• If degree of i is 2, then D(i) = {j ∈ V : (i, j) ∈ E0}.

For issues regarding the compatibility of ortools functions, the code version V3 was run on a different machine with respect to versions V1 and V2, so the computational results are not fully comparable and we prefer not to report them in detail in Section

with 14 or 15 target points, V3 proves to be remarkably faster than version V1 and V2. However, in smaller-sized instances, invoking the filtering algorithm for the Circuit constraint generally slows down the overall procedure.