Extension of a Label

In the Selector algorithm, the extension of a label λ = [ζ, ν, ω] from vertex σ_ν to a successor vertex σ_kwith k > ν implies that one of two possible operations is performed:

visit vertex σ_k or skip vertex σ_k. However, at every extension, feasibility must be maintained and redundant vertices must not be considered. Therefore, when no vertex w_i ∈ W , is left uncovered the label λ is extended by skipping vertex σ_k. Whereas, when this restriction is not met, extension is done by visiting σ_k. The details of these operations are as follows.

Redundancy Checking. When extending the label by visiting σ_k, we need to ensure that σ_k is useful, i.e., that all the vertices w_i it covers are not already covered. For computational efficiency, a matrix relating the coverage of the vertices w_i ∈ W by the vertices v_j ∈ V is precomputed and kept at hand, so that information needed for decision-making is readily available.

Feasibility Checking. Let Ω denote the subset of vertices of W that are not covered by the subpath represented by label λ. When extending the label by skipping vertex σ_k, we must be certain that each w_i ∈ Ω is not affected by this decision. This is to say that, for each w_i ∈ Ω there still remain vertices ahead of σ_k which can be visited to cover it. The number of such vertices is kept through field ω. Thus, for each w_i ∈ Ω, feasible labels yield ω[i] > 0.

Look-Ahead Mechanism. This mechanism allows to further reduce the number of labels created. Let Ω^k be the set of vertices w_i that remain to be covered in the set of σ_k. If when extending a label it is found that a vertex σ_k must be visited in the future because it is the only one remaining that can cover a set Γ ⊆ Ω^k, then all the vertices w_i ∈ Ω^k, but one, are marked as covered. One vertex w_i ∈ Γ must remain uncovered, so that when vertex σ_k is reached, it proves useful. Looking ahead makes some label extensions unnecessary because redundant vertices are detected earlier and, therefore, are skipped. As a result, less labels are created. In addition, when the dominance test is applied, the sets compared are already taking into consideration vertices w_i ∈ Ω^k as covered, and this also helps to delete useless labels earlier.

Figure 4.2 provides an example where i < j < k. The label is extended to vertex σ_i, and it is found that for set Γ = {w₅, w₇} the only vertex that remains ahead which can cover it is vertex σ_k. Then, the vertices {w₂, w₄, w₇, w₉} ∈ Ω^k are marked as covered.

Vertex w₅ remains as uncovered, so that when vertex σ_k is reached, it is found useful.

This is, vertex w₅ remains as a sentinel to ensure vertex σ_k is included. The former implies that set Ω^j is now marked as covered, making vertex σ_j redundant. Therefore, when σ_j is reached no labels are produced.

σi−1 σ_i σ_j σ_k

. . . . . . . . . . . .

Ω^j = {w₂, w9} Ω^k= {w₂, w4, w5, w7, w9} Figure 4.2: Portion of a giant tour used to exemplify the look-ahead mechanism.

Algorithm for Extending a Label. Algorithm 9 shows the specific implementation of Algorithm 6 for the CTP. It depicts how a label is iteratively extended to the adjacent successor vertex to maintain feasibility and efficiency. Label λ_current stores the last vertex visited in the path, and label λ_j memorizes the vertex to which the label is extended, σ_j. Set Ω contains the vertices w_i ∈ W that are already covered by the path, and set Ω^j contains the vertices that remain to be covered in the set of vertex σ_j. Set Λ^j contains the non-dominated labels stored at σ_j. At every step of the label extension, the following conditions are verified:

i. vertex to be included is not redundant (line 3) ii. ζ(λ_j) < UB_best (line 6)

iii. label is non-dominated (line 9)

First, it must be ensured that the vertex is useful. Any vertex that turns out to be redundant is simply skipped and the construction of the path continues, no labels are kept for skipped vertices. It is important to note that in this test the look-ahead mechanism is also applied and the resources (vector ω) are updated. If the vertex is worth visiting, the label cost and label index ν are updated. Next, test (ii) guarantees that the search in that trajectory is abandoned if the cost of the path turns out to be worse than the cost of the incumbent best-known solution. This acts as a bounding mechanism that enables to further control the proliferation of labels. If test (ii) is true, it is possible that the extension yields a complete solution. In such case, the incumbent best-known upper bound is updated in order to improve the limits for the creation of labels, and the extension in that direction stops. Otherwise (no complete solution exists), test (iii) makes sure only useful labels are kept.

4.4 Performance Improvements

A version of Selector which uses bidirectional search with bounding was implemented in order to study the performance improvement that could be attained. In this search, the recurrence equation, dominance rule, label-extension procedures, feasibility and redundancy checking and use of an upper bound are symmetrical to those previously presented, albeit the look-ahead mechanism is not used.

The bidirectional search, however, includes the computation of a lower bound on the cost of the tour, which aims at reducing label proliferation. Having a good lower bound allows to identify non-promising labels that can be pruned. Then, at each step

4.4. Performance Improvements 71

Algorithm 9 : Extend(λ) in the CTP

Input: label to be extended λ = [ζ, ν, ω], UB_best, |Ω|

Output: labels derived from λ = [ζ, ν, ω]

{only non-dominated labels that can later be extended skipping are kept}

1: λ_current← λ

2: for ( j = ν + 1 to n − 1 ) do

3: if ( vertex σ_j is not redundant ) then

4: |Ω| ← |Ω ∪ Ω^j|

5: ζ(λj) ← ζ(λ_current) + cost(σ_current, σj)

6: if ( ζ(λ_j) < UB_best ) then

7: if ( |Ω| 6= |W | ) then

8: λ_current← λ_j

9: if ( λ_j non-dominated ) then

10: Λ^j ← Λ^j∪ {λ_j}

11: end if

12: else

13: UB_best← ζ(λ_j)

14: return {complete solution has been built}

15: end if

16: else

17: return {cost of path being explored is worse than best-known cost}

18: end if

19: end if

20: end for

of the label extension, a lower bound on the cost of the complete tour represented by the label needs to be computed. The obtained bound can be compared against the incumbent best-known cost in order to determine if the label created by visiting that vertex is worth storing for further extension. One way to estimate the cost of the path that remains to be searched is by solving a Fractional Knapsack Problem (FKSP).

Both mechanisms—computation of a bound and bidirectional search—are thoroughly explained in Chapter 3. Hereafter, the explanation indicates only the specifics of the computation of the lower bound. To estimate the cost of a complete path, Equation 4.1 can be used.

µ(λ) = ζ + h(λ) (4.1)

where

• λ = [ζ, i, ω] is a label that memorizes σ_i as the last visited vertex

• Ω is a set of vertices that remain to be covered

• h(λ) is a lower bound computed on the cost incurred to cover the vertices w_j ∈ Ω visiting only vertices in the subsequence ϕ = {σ_i+1, . . . , σ_n−1}. This is, cover the remaining vertices w_j using only vertices that lie ahead of σ_i.

In the FKSP solved in order to estimate the cost of the unexplored path, the profit of an object σ_i ∈ ϕ is given by the number of vertices w_j ∈ W the object covers, and the capacity of the knapsack is given by |Ω|. The value of bound h(λ) is then the sum of the weight values of the vertices chosen from ϕ. Figure 4.3 shows an example. Let us consider that the figures in parenthesis indicate the vertices w_i ∈ W covered by vertices σ_i | i ∈ {1, . . . , 6}, and that the label has been extended up to vertex σ₃ and no vertex has been skipped. Also, |W | = 28 and 13 vertices w_i ∈ W have been covered.

First, we determine the capacity of the knapsack which is given by the vertices that remain to be covered: C = |W | − |Ω| = |Ω|. Applying this equation to our example yields C = 28 − 13 = 15.

Next, we define the objects that will be put into the knapsack. These are vertices ϕ = {σ4, σ5, σ6}. The problem is solved with a greedy approach, so we need to deter-mine the ratio prof it/weight for each item in ϕ. The profit is a piece of data stored for each σ_i, and its weight d_i is computed in each iteration as follows. Let ∆_i = {d_ji}ⁱ⁻¹_j=0 be the set of weights of the in-going edges of σ_i, those that connect vertex σ_i with each of its predecessor vertices in the giant tour σ, and ∆⁰_i = {d_ik}ⁿ⁻¹_k=i+1∪ {d_i0} be the set of weights of the out-going edges of σ_i, those that connect vertex σ_i with each of its successor vertices in σ. Then, an estimation of the least travel cost (weight) of visiting vertex σ_i can be obtained by

di = min ∆_i+ min ∆⁰_i (4.2)

Exemplifying this for vertex σ₄ we have ∆₄ = {d(0, 4), d(1, 4), d(2, 4), d(3, 4)},

∆⁰₄ = {d(4, 5), d(4, 6), d(4, 0)}, and d₄ = min ∆₄ + min ∆⁰₄. The same applies for the rest of the vertices in ϕ. Since our greedy strategy is to choose the items with the largest profit per unit weight first, we order these items in decreasing order of their prof it/weight ratio. Let us suppose we get σ6, σ₄, σ₅. Then, we choose the items in this order, so we take all of σ₆ and σ₄, C = 15 − 7 − 6 = 2. However, the greedy algorithm never wastes any capacity in the FKSP, so we can use the 2 units of the remaining capacity to take 2

5 of σ₅. Then, our total estimated cost for the path that remains to be explored is h(λ) = d₆+ d₄+2

5d5.

σ0 σ1 σ2 σ3 σ4 σ5 σ6

(0) (6) (5) (4) (6) (5) (7)

Figure 4.3: Giant tour used to exemplify the computation of a lower bound.

Applying this result to the original problem, if µ(λ) ≥ UB_best, the label can be pruned. Otherwise, the label is stored if it is non-dominated. In the bidirectional version