Docstoc

On the Rural Postman Problem Tight Bounds and Efficient

Document Sample
On the Rural Postman Problem Tight Bounds and Efficient Powered By Docstoc
					                                          On the Rural Postman Problem:

                    Tight Bounds and Efficient Heuristics Based on a New Formulation




                                                         Authors:

                                                      Elena Fernández
                                      Statistics and Operations Research Department
                                        Polytechnic University of Catalunya, Spain
                                                  e-mail: elena@eio.upc.es

                                                     Oscar Meza1
                               Computer Science and Information Technology Department
                                              Simón Bolívar University
                                         Apartado 89000, Baruta, Venezuela
                                              e-mail: meza@ldc.usb.ve

                                                  Robert Garfinkel
                                          School of Business Administration
                                              University of Connecticut
                    368 FairField Road, U-41IM, Room 302, Storrs, Connecticut 06269-2041, U.S.A.

                                                   Maruja Ortega1
                               Computer Science and Information Technology Department
                                              Simón Bolívar University
                                         Apartado 89000, Baruta, Venezuela
                                              e-mail: meza@ldc.usb.ve

                                                       Abstract

In this work we focus on a new integer programming approach for the Rural Postman Problem which is not equivalent to
any of the previous models. Previous models have general integer variables and a combination of linear and modular
constraints. This contrasts with our formulation which is mixed linear integer programming where the integer variables
are binary.

The algorithmic possibilities of the model to provide both sharp lower bounds and good feasible solutions are explored.
We propose a cutting plane algorithm based on a very few number of valid inequalities as compared with previous works
and resulting in very sharp lower bounds.

Different types of inequalities are valid for the considered model. We include matching inequalities, connectivity
inequalities, K-C inequalities and some new even-cycle inequalities for which a simple separation procedure is given.
These inequalities have been used as cutting planes to strenghthen the LP relaxation of our model. Most of the test
problems have been optimally solved and for the problems where optimality is not achieved the gap with respect to the
best known solution is extremely small.

From the heuristic point of view, the best known heuristic is probably that suggested by Frederickson. The properties of
the new model are taken into account to derive an efficient postoptimization heuristic that provide feasible solutions of


1
    This research has been partially supported by the Spanish Agency of Iberoamerican Cooperation (A.E.C.I.)
a remarkable quality when executed after Frederickson’s heuristic and other heuristics based on the cutting plane
algorithm solution.


1. Introduction

In [6], Garfinkel&Webb propose a mixed integer programming model for the Rural Postman Problem (RPP), where all
the integer variables are binary. In this formulation, every feasible solution is a solution to the RPP, but the contrary is
not true. However, there is at least one optimal solution in the set of feasible solutions of the model.

In 1981 Christofides&al.[4] proposed an integer programming model for the RPP, which we will call “the classic
model”. This model is the only one that has previously been proposed for the RPP, to the knowledge of the authors.
The classic model has been used by the following researchers, who have been working on the RPP for several years:
Angel Corberán (University of Valencia, Spain), J. Sanchis (University of Valencia, Spain), A. Hertz (University of
Montreal), Gianpaolo Ghiani (University of Montreal), Gilbert Laporte (University of Montreal), Adam Letchford
(University of Lancaster).

The main differences between the classic model and the model proposed by Garfinkel&Webb are: first, the set of
feasible solutions to Garfinkel&Webb’s model is a subset of the set of all feasible solutions to the RPP; second, the
number of constraints in the classic model is exponential, while in Garfinkel&Webb’s model, it is a linear function on
the number of nodes of the graph; and third, Garfinkel&Webb’s model reduces to find a perfect matching satisfying
certain conditions, while the classical model maintains the original nature of the problem.

Recent research on the RPP has followed mainly the following three directions:
a) Generate valid inequalities and facets of the convex hull of solutions of the RPP.
b) Use of results from (a) to design cutting plane or branch and cut algorithms .
c) Design of approximation algorithms for the RPP:

Our first interest has been to explore the algorithmic possibilities of the Garfinkel&Webb’s model to provide both
sharp lower bounds and good feasible solutions for the RPP.

This report is organized as follows : In section 2 we present the classical model for the RPP, the most recent results
based on this model and a short comment on approximation algorithms for the RPP. In section 3 we present
Garfinkel&Webb’s model for the RPP and we propose two other similar models based on it , where the number of
variables as well as the number of constraints is reduced. We also present the Lagrangean Relaxation for these models.
In section 4, we do a comparison of models in order to show that Garfinkel&Webb’s model is a quite different model
from the previous models. Section 5 present new valid inequalities for the Garfinkel&Webb’s model which can be
used in separation algorithms. A cutting plane algorithm (the MCK algorithm) and an heuristic (the Three-Tree
heuristic) based on Garfinkel&Webb’s model are presented in section 6. In Section 7 we discuss computational results.
Finally, the conclusions of the work are presented in section 8.

2. Previous results for the RPP

In this section we present in a very resumed manner what we consider have been the most significant contributions on
the RPP using mathematical programming.

Definition of the RPP.

Let G=(V,E) be a connected undirected graph, without multiple edges. Let C: E → ℜ be a cost function on the set of
edges E. Let ER ⊆ E be a subset of edges of E.

The Rural Postman Problem (RPP) consists of finding a least cost closed path in G that includes, at least once, each
edge in ER.
By closed path we mean an alternate sequence <v0,e 1,v1,e 2,v2, ... ,e n,vn> where each vi is a node, each ei is an edge, v0=vn,
and the endpoints of each e i are vi-1 and vi. The cost of a path is the sum of the costs of the edges in it. If an edge appears
more than once in a path, its cost will be added to the cost of the path as many times as the edge appears in it.

A closed path that includes every edge in ER will be referred to in this work as a “tour for the RPP”.

The RPP can be stated in different ways. Christofides&al.[4] proposed to transform the original graph G in the
following way: Let GR= (VR, ER) be the subgraph of G induced by the set of edges ER. We call a connected component
of GR an R-connected component. A set of vertices defining an R-connected component will be called an R-set. Build
the graph GP = (VR, ER ∪ EP ) adding to GR an edge joining each pair of vertices in VR with a cost equal to the cost of a
minimum cost path between them (calculated on the original graph G). It can be seen easily that every optimal solution
to the RPP in GP produces an optimal solution to RPP in G, with the same cost.

In the formulation of Christofides&al. the number of edges in GP is reduced by eliminating:
- the edges {i,j} in EP for which C({i,j}) = C({i,k}) + C({k,j}) for some k. C({i,k}) and C({k,j}) must be non-zero to
  guarantee that the obtained graph has at least one path from i to j with cost C({i,j}),
- one of each pair of parallel edges if both have the same cost .

Let GS = (VR, ER ∪ ES) be the resulting graph after eliminating edges from GP as described above. For each edge e in
GS, define the variable xe as the number of times that e appears in a tour for the RPP, if e ∉ ER, or this same number
minus one if e ∈ ER. If F is a subset of edges, x (F) will represent the sum of all variables corresponding to edges in F.

For W ⊂ VR let Ω(W) be the set of edges in GS with one endpoint in W and the other in VR\W. Let Ω R(W) = Ω(W) ∩
ER. We also write E(W:T) for Ω(W) ∩ Ω(T) and ER(W:T) for E(W:T) ∩ER. Let V1, V2, ... , Vm be the R-sets. Let dR(v)
denote the degree of vertex v in GR. An R-odd (R-even) vertex is a vertex with dR(v) odd (even).

Formulation of Christofides for the RPP, denoted by RPP(CHR):

                     min      ∑ C (e)(1 + x ) + ∑ C (e) x
                                                       e                e
                              e∈ER                          e∈ES


subject to:

                  ∑ (1 + x ) + ∑ x e                   e
                                                           = 2zv    (v ∈ VR)
              e∈Ω (v ) ∩ ER                e∈Ω (v ) ∩E S

                 ∑x       e   ≥2                                   (P ⊂ {1,2,...,m}, P ≠ ∅, S =   UV     k   )
               e∈Ω (S )                                                                           k ∈P
               xe ≥ 0         and integer (e ∈ ER ∪ ES )
               zv ≥ 0         and integer (v ∈ VR)


The formulation used by Corberán&al. [3] is equivalent to Christofides’s but it is presented in a more concise format.

Formulation of Corberán for the RPP, denoted by RPP(COR):

                          min          ∑ C (e) x
                                e∈ER ∪ E S
                                                   e


subject to:

(1)    x(Ω(v)) ≡ dR(v) mod 2                   (v ∈ VR)
(2)    x(Ω (S)) ≥ 2                             (S ⊂ VR, Ω R(S) = ∅ )
(3)     xe ≥ 0    and      x e integer (e ∈ ER ∪ ES )

Both of the above formulations are equivalent. Both have |VR| + 2m-1 constraints plus the integrity and non-negativity
constraints. Corberan’s formulation presents the difficulty of having “modulus” constraints.

The set of feasible solutions to (1), (2), and (3) corresponds to the set of tours for the RPP. Valid inequalities are
inequalities satisfied by all feasible solutions. Corberán&al.’s main interest have been on finding valid inequalities and
facets of the convex hull of feasible solutions for (1), (2) and (3), based on the above formulation (see [3], [2]). They
have classified the valid inequalities found as:

-     Non negativity inequalities, those of (3).
-     Connectivity inequalities, those of (2).
-     R-odd inequalities:
      For S ⊂ VR, |Ω R(S)| odd:

                 x(Ω (S)) ≥ 1 is an R-odd inequality

-     K-Component (or K-C) inequalities:

      A K-C configuration is a partition {V0, … , VK} of vertex set of GS, with K ≥ 3, such that
      • V1, …, VK-1 and V0 ∪ VK are cluster of one or more R-sets,
      • ER(V0:VK) is positive and even,
      • E(Vi:Vi+1 ) ≠ ∅ for i=0, … , K-1.

      The corresponding K-C inequality can be written as:

                   (K − 2 )x ( E (V 0 : V K )) +         ∑ i − j x( E(V   i   : V j )) ≥ 2( K − 1)
                                                   0≤ i < i ≤ K
                                                   (i , j ) ≠ (0 , K )


-     More specialized inequalities: Path-Bridge and HoneyComb inequalities.

In [3], Corberán&al. present an exact algorithm for the GRP (Generalized Routing Problem) which consist of a cutting
plane algorithm based on the above valid inequalities. Their algorithm works well for RPP instances.

Ghiani&Laporte [1] use a similar formulation to Corberán’s where all the variables are binary. They show that there is
an optimal solution for the RPP where all the variables are binary except at most m-1 variables that are equal to 2.
These variables correspond to the set of edges of a minimum cost spanning tree in the reduced graph of GR that has one
vertex Vi for each connected component Ci of GS, and one edge joining each pair V, Vj of vertices associated to
                                                                                        i
components Ci, Cj, with cost equal to the cost of the edge of minimum cost between Ci and Cj in GS. The edges in GS
corresponding to the minimum cost spanning tree are called “012 edges”, and the remaining edges are called “01
edges”. The sets formed by 012 and 01 edges are called E012 and E01 respectively.

Each 012 edge e is replaced by a pair of parallel edges e’ and e’’. Let E’ and E’’ be the sets corresponding to these
edges. The formulation of Ghiani&Laporte can be obtained after the following substitution in RPP(COR):

                             xe = xe’ + xe’’           (e is a 012 edge)
                             xe’, xe’’                 binary

Formulation of Ghiani&Laporte for the RPP, denoted by RPP(GHI):
                          min   ∑ C (e) x   e

                                e∈E


subject to:

(a)    x(Ω (v)) ≡ dR(v) mod 2         (v ∈ VR)

(b)    x(Ω (S)) ≥ 2                   (S ⊂ VR, Ω R(S) = ∅ )
(c)    xe binary                   (e ∈ E )

where E = Ε01∪E’∪E’’


Note that the feasible solutions to RPP(GH) form a subset of the set of tours for the RPP, but that this subset contains
an optimum tour.

In view of the difficulties that continues to present the above formulation, due to the modulus constraints (a), and to the
exponential number of constraints (b), they propose in their article new valid inequalities that they call R-even, and they
propose a branch and cut algorithm that gives good lower bounds at the root of the branch tree.

The R-even inequalities are defined as follows:

                For S ⊂ VR, S ≠ ∅, |Ω R(S)| even:

                x(Ω (S\{e *}) ≥ xe*       (e* ∈ Ω (S)) is an R-even inequality


In order to avoid the modulus constraints, Ghiani&Laporte define a 0-1 program with connectivity, R-odd and R-even
constraints only. Optimal solutions of this new integer program are not necessarily optimal tours for the RPP. They
propose a branch and cut algorithm on this 0-1 program. When in the algporithm an optimal solution to the relaxed 0-1
problem is 0-1 but not feasible for RPP(GHI), the valid inequality:

                          x(Ω (vi)\Ei) ≥ x(Ei) - |Ei| + 1

(where Ei is the set of edges e incident to vi for which xe=1 in the actual optimal solution) is added for each node vi that
violates the degree constraints.


On approximation algorithms:

The best known heuristic up to now for the RPP is the one proposed by G.N. Federickson [5]. This heuristic first
determines the set of edges in a minimum cost spanning tree joining the connected components of GR (as seen before),
then adds these edges to GR and afterwards finds a minimum cost perfect matching on the odd degree vertices in this
new graph. Hertz&al [8] have proposed several proceedings for improving the solution obtained by Federickson’s
method.


3. Garfinkel&Webb’s Model for RPP


3.1 Formulation of Garfinkel&Webb for the RPP and its variants
In their work [6] Garfinkel &Webb propose a new definition for the RPP:
Definition: Let GR=(VR,ER) be a non oriented and not necessarily connected graph, where each connected component
contains at least one edge. Let ED={{i,j}/i∈VR and j∈VR, i≠j}, with costs (or distances) dij associated to each {i,j}.
Find a multiset (a collection of not necessarily distinct elements) EP of edges in ED, with minimum total cost, such that
GR∪P =(VR, ER∪EP ) is eulerian (i.e. connected with all nodes having even degree).

If GR∪P is eulerian, it has an eulerian cycle that traverses each edge in ER∪EP exactly once.        Note that since EP is a
multiset, it may contain more than one copy of an edge e in ED.

The above definition is equivalent to the definition given in section 2 since the costs dij correspond to the cost of a
minimum cost path between i and j in the original graph G=(V,E) and ER is the set of required edges.

In [6], several lemmas are proposed that lead to a structural characterization of a subset of optimal solutions for the
RPP. These lemmas are also the basis for a new formulation of the RPP. The main advantages of this new formulation
are that, first, the number of constraints is a linear function on the number of vertices of the graph, second, the set of
feasible solutions to this formulation, which includes some optimal solutions, is a subset of all tours to the RPP, and
third, the problem is now reduced to find a minimum cost perfect matching in a given graph as will be seen bellow.

The lemmas on which the new formulation is based are the following:

Lemma 2: There is an optimal solution to the RPP in which, within any connected component Ck of GR, any pair of
nodes i,j ∈ Ck are connected by at most one edge in EP .

Lemma 3: There is an optimal solution to the RPP in which, within any component Ck of GR, every edge {i,j} in EP
connects a pair of R-odd vertices (i.e., vertices with odd degree in GR.).

Lemma 4: There is an optimal solution to the RPP in which every R-even vertex i in V has P-degree equal to zero or
two, i.e., there are either two or zero edges in EP that are incident on i.

Let ED={{i,j}/i∈VR and j∈VR, i≠j}, with costs dij associated to each {i,j}. Denote Ci the connected component of GR
that contains vertex i. The problem of finding a tour for the RPP, or equivalently, a multiset EP of edges in ED with
minimum total cost, such that (V,EP ∪ ER) is eulerian, can then be formulated as follows:

First, build a new graph GA =(VA, EA) from GR. VA contains all nodes in VR plus a new node i’ for each R-even vertex i.
EA contains edges connecting every pair i,j of nodes in VA, except edges {i,j}, {i’,j} y {i’,j’}, when j is in the same
component Ci as i, dR(i) is even and j≠i. The cost of an edge {i,j} is dij , the cost of {i,i’} is zero, and dij’ = dj’i = dij.

Let EA* = {{k,l} ∈EA, CR(k) ≠ CR(l)} where R(k)=i if k=i or k=i’. Let Ek+ be the set of edges incident on node k in GA.

Let MA be a perfect matching in GA. Let Ep be the multiset of edges obtained as follows: if {i,j} ∈ MA with R(i) ≠ R(j),
then {R(i),R(j)} ∈ Ep. As can be seen, finding an optimal solution for the RPP is equivalent to finding a minimal cost
perfect matching in GA such that (V,EP ∪ ER) is connected, where EP is obtained from the optimal perfect matching.

Formulation of Garfinkel&Webb for the RPP, denoted by RPP(GW):

We define variables xij, i ≤ j, associated to each edge {i,j} in EA. We also define variables ykl and ylk associated to
each edge {k,l} in EA*.

(1)      min      ∑d
               { i , j }∈E A
                               ij x ij
subject to:



(2)           ∑x  +
                      ij   = 1, k ∈ V A
         {i , j}∈Ek



(3)           ∑ ∑                 y kl   = m −1
         k :R ( k )∈C1 l :R (l )∉C1 ,
                       {k ,l}∈ E A


(4)           ∑             ∑     y kl
         k :R ( k )∉Ct l :R (l )∈Ct ,
                                         −      ∑               ∑    y lk
                                             k: R (k )∉Ct l: R( l )∈Ct ,
                                                                            = 1,         t = 2,..., m

                       { k ,l}∈ E A
                                  *
                                                          {k ,l }∈E A*




(5)      y kl ≤ ( m − 1) x ij , (k , l) = (i, j) ∨ (l, k ) = (i, j),                     {i, j} ∈ E *
                                                                                                    A




(6)      x ij ∈ {0,1}, {i, j} ∈ E A


(7)      y kl ≥ 0, (k , l ) = (i, j) or (l, k ) = (i, j),                        {i, j} ∈ E *
                                                                                            A


As has been mentioned, finding an optimal solution for the RPP is equivalent to finding a minimal cost perfect matching
in GA such that (V,EP ∪ ER) is connected, where EP is obtained from the optimal matching. Constraints (1), (2) y (6)
define a minimum cost perfect matching in GA. Constraints (3),(4) and (7) define a network flow problem on the ‘y’
variables. This flow induces a spanning connected subgraph on the reduced graph of GA (whose vertices are the
connected components of GA) , in which m units of flow must be sent from component C1 to the other components.
These variables are used to guarantee connectivity which is established in (5), called the “link” constraints, relating both
types of variables .

Example 1:

Let G=(V,E) be a non oriented graph with:

V={1,2,3,4,5,6,7},
E={{1,2},{2,3},{1,3},{2,4},{4,5},{2,6},{6,7}},
ER={{1,2},{2,3},{4,5},{6,7}}

Figure 1 shows graphs G and GA. Dark edges are those in ER .

Distances: d12=2, d23=1, d13=1, d24=1, d45=1, d26=1, d67=1.



                                 1              1           3                                       1                   3

                                         2            1
                                                                                                             2 2’
                                                2
                                         1             1

                                1                               1
                       5                  4           6                     7                   5        4          6       7


                                         G=(V,E)                                                        GA=(VA,EA)

                                                                                Figure 1
Build GA=(VA,EA) with:

VA = {1,2,2’,3,4,5,6,7}

EA = {{1,3}, {4,5}, {6,7}, {1,4}, {1,5}, {1,6}, {1,7}, {2,2’}, {2,4}, {2,5}, {2,6}, {2,7}, {2’,4}, {2’,5}, {2’,6},
{2’,7}{3,4}, {3,5}, {3,6}, {3,7}, {4,6}, {4,7}, {5,6}, {5,7}}

Distances: d13=1, d45=1, d67=1, d14=3, d15=4, d16=3, d17=4, d22’=0, d24=1, d25=2, d26=1, d27=2, d2’4=1, d2’5=2,
d2’6=1, d2’7 =2, d34=2, d35=3, d36=2, d37=3, d46=2, d47=3, d56=3, d57=4.

RPP(GW) for this example is:

Minimize 1x13 + 3x14 + 4x15 + 3x16 + 4x17 + 1x24 + 2x25 + 1x26 + 2x27 + 1x2’4 + 2x2’5 + 1x2’6
+ 2x2’7 +2x34 + 3x35 + 2x36 + 3x37 + 1x45 + 2x46 + 3x47 + 3x56 + 4x57 + 1x67

s.t.

x13 + x14 + x15 + x16 + x17 =1
x22’ + x24 + x25 + x26 + x27 =1
x22’ + x2’4 + x2’5 + x2’6 + x2’7 =1
x13 + x34 + x35 + x36 + x37 =1
x14 + x24 + x2’4 + x34 + x45 + x46 + x47 =1
x15 + x25 + x2’5 + x35 + x45 + x56 + x57 =1
x16 + x26 + x2’6 + x36 + x46 + x56 + x67 =1
x17 + x27 + x2’7 + x37 + x47 + x57 + x67 =1
y14 + y15 + y24 + y25 + y2’4 + y2’5 + y34 + y35 + y16 + y17 + y26 + y27 + y2’6 + y2’7 + y36 + y37 = 2
y14 + y15 + y24 + y25 + y2’4 + y2’5 + y34 + y35 + y64 + y65 + y74 + y75 – y 46 – y 47 – y 56 – y 57 = 2
y14 + y15 + y24 + y25 + y2’4 + y2’5 + y34 + y35 + y64 + y65 + y74 + y75 – y 46 – y 47 – y 56 – y 57 = 1
y16 + y17 + y26 + y27 + y2’6 + y2’7 + y36 + y37 + y46 + y47 + y56 + y57 – y 64 – y 65 – y 74 – y 75 = 1
y14 ≤ 2x14     y15 ≤ 2x15     y16 ≤ 2x16 y17 ≤ 2x17
y24 ≤ 2x24     y25 ≤ 2x25     y26 ≤ 2x26 y27 ≤ 2x27
y2’4 ≤ 2x2’4 y2’5 ≤ 2x2’5        y2’6 ≤ 2x2’6 y2’7 ≤ 2x2’7
y34 ≤ 2x34     y35 ≤ 2x35     y36 ≤ 2x36 y37 ≤ 2x37
y46 ≤ 2x46     y64 ≤ 2x46     y47 ≤ 2x47 y74 ≤ 2x47
y56 ≤ 2x56     y65 ≤ 2x56     y57 ≤ 2x57 y75 ≤ 2x57

with x ij ∈ {0,1}, ykl ≥0.


RPP(GR): Variant of RPP(GW) with flow variables defined between R-sets.

RPP(GW) can be slightly modified, as will be shown, in order to reduce the number of flow variables, i.e., y´s variables.

Let C1, C2, ... Cm be the connected components of GR. Define flow variables ykl, with k=1,...,m and l=2,...,m, for each
pair of components Cl, Ck . This new formulation reduces both, the number of flow variables and the number of “link”
constraints.
The formulation is as follows:


(1)      min        ∑d
                 { i , j }∈E A
                                 ij   x ij


subject to:



(2)           ∑x  +
                       ij   = 1, k ∈ V A
         {i , j}∈Ek



(3)
            {
              ∑    y1k
         k ∈ 2,...,m}
                             = m −1


(4)      ∑ y −∑y
          k ≠t
                  kt
                            k ≠t
                                        tk   = 1 t = 2 ,..., m


(5)       y kl ≤ (m − 1) ×                    ∑
                                        {i , j}∈E A :
                                                  *
                                                      x ij ,   k ≠ l , k = 1,..., m   l = 2 ,..., m

                                        (i∈Ck ∧ j∈Cl )∨
                                        ( j∈Ck ∧i∈Cl )


(6)       x ij ∈ {0,1}, {i, j} ∈ E A

(7)       y kl ≥ 0, k ≠ l , k = 1,..., m                         l = 2 ,..., m


For the problem of Example 1, formulation RPP(GR) is:


Minimize 1x13 + 3x14 + 4x15 + 3x16 + 4x17 + 1x24 + 2x25 + 1x26 + 2x27 + 1x2’4 + 2x2’5 + 1x2’6
+ 2x2’7 +2x34 + 3x35 + 2x36 + 3x37 + 1x45 + 2x46 + 3x47 + 3x56 + 4x57 + 1x67

s.t.

x13 + x14 + x15 + x16 + x17 =1
x22’ + x24 + x25 + x26 + x27 =1
x22’ + x2’4 + x2’5 + x2’6 + x2’7 =1
x13 + x34 + x35 + x36 + x37 =1
x14 + x24 + x2’4 + x34 + x45 + x46 + x47 =1
x15 + x25 + x2’5 + x35 + x45 + x56 + x57 =1
x16 + x26 + x2’6 + x36 + x46 + x56 + x67 =1
x17 + x27 + x2’7 + x37 + x47 + x57 + x67 =1
y12 + y13 = 2
y12 + y32 – y 23 = 1
y13 + y23 – y 32 = 1
y12 ≤ 2(x 14 + x15 + x24 + x25 + x2’4 + x2’5 + x34 + x35)
y13 ≤ 2(x 16 + x17 + x26 + x27 + x2’6 + x2’7 + x36 + x37)
y23 ≤ 2(x 46 + x47 + x56 + x57)
y32 ≤ 2(x 46 + x47 + x56 + x57)

with x ij ∈ {0,1}, ykl ≥ 0.



As can be seen, the number of flow variables ykl, as well as the number of “link” constraints is reduced considerably
with respect to formulation RPP(GW).


RPP(GA): Variant of RPP(GW) using spanning tree.

Another alternative formulation may be obtained by redefining again the flow variables used to guarantee the
connectivity of the solution.

Let C1, C2, ... Cm again be the connected components of GR. We define variables 0-1 variables ykl corresponding with
components Ck y Cl, k<l , is present or not in the solution. This reduces almost by a half the number of y variables , as
well as the number of “link” constraints, respect to formulation RPP(GR). However, the number of constraints (4) that
define will be 2 m-1.

The problem on y variables consists in finding a spanning tree on the complete graph of order m whose vertices are
associated respectively to components C1, C2, ... Cm . The formulation for the RPP is then the following:




(1)      min         ∑d
                  { i , j }∈E A
                                  ij   x ij


subject to:



(2)           ∑x  +
                        ij   = 1, k ∈ V A
         {i , j}∈Ek




(3)      ∑y
          k <l
                   kl    = m −1


(4)       ∑y        kl       ≤ S − 1,         S ⊂ {1,..., m}, 1 < S < m
         k <l ,
         k ,l∈S



(5)       y kl ≤              ∑ x ij            ∀k < l ,   k , l ∈ {1,..., m}
                     (i∈Cl ∧ j∈Ck ) ∨
                     ( j∈Cl ∧ i∈Ck )


(6)       x ij ∈ {0,1}, {i, j} ∈ E A

(7)       y kl ∈ {0 ,1}, k < l, k , l ∈ {1,..., m}
RPP(GA) for the same example is:

Minimize 1x13 + 3x14 + 4x15 + 3x16 + 4x17 + 1x24 + 2x25 + 1x26 + 2x27 + 1x2’4 + 2x2’5 + 1x2’6
+ 2x2’7 +2x34 + 3x35 + 2x36 + 3x37 + 1x45 + 2x46 + 3x47 + 3x56 + 4x57 + 1x67

s.t.

x13 + x14 + x15 + x16 + x17 =1
x22’ + x24 + x25 + x26 + x27 =1
x22’ + x2’4 + x2’5 + x2’6 + x2’7 =1
x13 + x34 + x35 + x36 + x37 =1
x14 + x24 + x2’4 + x34 + x45 + x46 + x47 =1
x15 + x25 + x2’5 + x35 + x45 + x56 + x57 =1
x16 + x26 + x2’6 + x36 + x46 + x56 + x67 =1
x17 + x27 + x2’7 + x37 + x47 + x57 + x67 =1
y12 + y13 + y23 = 2
y12 ≤ 1
y13 ≤ 1
y23 ≤ 1
y12 ≤ x14 + x15 + x24 + x25 + x2’4 + x2’5 + x34 + x35
y13 ≤ x16 + x17 + x26 + x27 + x2’6 + x2’7 + x36 + x37
y23 ≤ x46 + x47 + x56 + x57

with x ij ∈ {0,1}, ykl ∈ {0,1}

Again, it can be seen in this example that the number of variables ykl as well as the number of “link” constraints are
reduced respect to RPP(GW) or RPP(GR).

3.2 Lagrangean Relaxation for Garfinkel&Webb’s formulation and its variants RPP(GR) and RPP(GA).

Due to the structure of the problem that arises using Garfinke&Webb’s model for the RPP or any of the two proposed
variants, the Lagrangean Relaxation technique seems a very good alternative for finding lower bounds or approximate
solutions. In this case, by relaxing the “link” constrains we obtain two different and separate problems, one on the set
of variables x (a perfect matching problem) and another on the set of variables y (a network flow or a spanning tree
problem) . The problem of finding lagrangean multipliers, maxµ≥0 L(µ), can be solved using either a classical technique
such as the subgradient method, or by designing a heuristic that exploits the structure of the problem. The classic
technique did not provide good lower bounds, but it would be worthwhile to explore heuristic methods, specially in the
RPP(GA) model.

Lagrangean Relaxation for problem RPP(GW):

Define variables µkl associated to each of the constraints in (5) of RPP(GW).

Given a vector µ ≥0, the Lagrangean L(µ ) is defined as:

(1)      minimize     ∑d          ij   x ij +          ∑µ        kl ( y kl   − (m − 1) ∗ x ij ) +µ lk ( y lk − (m − 1) ∗ x ij )
                    {i , j}∈E A                 (i ,   j )∈E A
                                                             *




s.t.
(2)         ∑x    +
                      ij   = 1, k ∈ V A
         {i , j}∈Ek




(3)         ∑                  ∑       y kl   = m −1
         k :R ( k )∈C1      l :R (l )∉C1 ,

                            {k ,l }∈E *
                                      A




(4)         ∑
         k :R ( k )∉Ct
                               ∑       y kl
                            l: R( l )∈Ct ,
                                                −      ∑
                                                    k :R ( k )∉Ct
                                                                       ∑       y lk
                                                                    l: R (l )∈Ct ,
                                                                                      = 1,      t = 2,..., m

                            { k ,l }∈E A
                                       *
                                                                    { k ,l }∈E A
                                                                               *




(5)       x ij ∈ {0,1}, {i, j} ∈ E A


(6)       y kl ≥ 0,          (k , l) = (i, j) ∨ (l, k ) = (i, j),                {i, j} ∈ E *
                                                                                            A




For a fixed value of µ, L(µ ) can be solved by solving separately the minimum cost matching problem on the x variables
and the minimum cost flow problem on the y variables. Efficient and well known algorithms exist for both of these
problems.

The formulation of the Lagrangean Relaxation for RPP(GW) for the problem example in previous section would be:

Minimize 1x13 + 3x14 + 4x15 + 3x16 + 4x17 + 1x24 + 2x25 + 1x26 + 2x27 + 1x2’4 + 2x2’5 + 1x2’6
+ 2x2’7 +2x34 + 3x35 + 2x36 + 3x37 + 1x45 + 2x46 + 3x47 + 3x56 + 4x57 + 1x67
+ µ14 (y14 – 2x14) + µ15 (y15 – 2x15) + µ16 (y16 – 2x16) + µ17 (y17 – 2x17)
+ µ24 (y24 – 2x24) + µ25 (y25 – 2x25) + µ26 (y26 – 2x26) + µ27 (y27 – 2x27)
+ µ2’4 (y2’4 – 2x2’4) + µ2’5 (y2’5 – 2x2’5) + µ2’6 (y2’6 – 2x2’6) + µ2’7 (y2’7 – 2x2’7)
+ µ34 (y34 – 2x34) + µ35 (y35 – 2x35) + µ36 (y36 – 2x36) + µ37 (y37 – 2x37)
+ µ46 (y46 – 2x46) + µ64 (y64 – 2x46) + µ47 (y47 – 2x47) + µ74 (y74 – 2x47)
+ µ56 (y56 – 2x56) + µ65 (y65 – 2x56) + µ57 (y57 – 2x57) + µ75 (y75 – 2x57)

s.t

x13 + x14 + x15 + x16 + x17 =1
x22’ + x24 + x25 + x26 + x27 =1
x22’ + x2’4 + x2’5 + x2’6 + x2’7 =1
x13 + x34 + x35 + x36 + x37 =1
x14 + x24 + x2’4 + x34 + x45 + x46 + x47 =1
x15 + x25 + x2’5 + x35 + x45 + x56 + x57 =1
x16 + x26 + x2’6 + x36 + x46 + x56 + x67 =1
x17 + x27 + x2’7 + x37 + x47 + x57 + x67 =1
y14 + y15 + y24 + y25 + y2’4 + y2’5 + y34 + y35 + y16 + y17 + y26 + y27 + y2’6 + y2’7 + y36 + y37 = 2
y14 + y15 + y24 + y25 + y2’4 + y2’5 + y34 + y35 + y64 + y65 + y74 + y75 – y 46 – y 47 – y 56 – y 57 = 2
y14 + y15 + y24 + y25 + y2’4 + y2’5 + y34 + y35 + y64 + y65 + y74 + y75 – y 46 – y 47 – y 56 – y 57 = 1
y16 + y17 + y26 + y27 + y2’6 + y2’7 + y36 + y37 + y46 + y47 + y56 + y57 – y 64 – y 65 – y 74 – y 75 = 1
xij ≥ 0 ykl ≥ 0

Lagrangean Relaxation for RPP(GR):

Define variables µkl ≥0, associated to each constraint in (5) of RPP(GR).
The Lagrangean L(µ ) is:


(1)      minimize              ∑d
                            {i , j}∈ E A
                                           ij   x ij +     ∑
                                                         k =1,..,m
                                                                       µ kl ( y kl − (m − 1)     ∑      x ij )
                                                                                           {i , j}∈E A:
                                                                                                    *
                                                         l = 2,...,m                       (i∈C k ∧ j∈Cl )∨
                                                         k ≠l                              ( j∈Ck ∧i∈Cl )
s.t.


(2)      ∑x     +
                    ij   = 1, k ∈ V A
       {i , j}∈Ek



(3)       ∑
          {
                 y kl
       k ∈ 2,...,m}
                          = m −1


(4)       ∑ y −∑y
          k ≠t
                    kt
                            k ≠t
                                   tk      = 1 t = 2,..., m


(5)       x ij ∈ {0,1}, {i, j} ∈ E A

(6)       y kl ≥ 0, k ≠ l , k = 1,..., m                                l = 2 ,..., m

In this case again we obtain two separate problems, a matching problem and a flow problem. The difference with the
previous case is again the decrease in the number of flow variables.

For the example problem the Lagrangean Relaxation of RPP(GR) is:


Minimize 1x13 + 3x14 + 4x15 + 3x16 + 4x17 + 1x24 + 2x25 + 1x26 + 2x27 + 1x2’4 + 2x2’5 + 1x2’6
+ 2x2’7 +2x34 + 3x35 + 2x36 + 3x37 + 1x45 + 2x46 + 3x47 + 3x56 + 4x57 + 1x67
+ µ12 (y12 – 2(x 14 + x15 + x24 + x25 + x2’4 + x2’5 + x34 + x35))
+ µ13 (y13 – 2(x 16 + x17 + x26 + x27 + x2’6 + x2’7 + x36 + x37))
+ µ23 (y23 – 2(x 46 + x47 + x56 + x57))
+ µ32 (y32 – 2(x 46 + x47 + x56 + x57))

s.t.

x13 + x14 + x15 + x16 + x17 =1
x22’ + x24 + x25 + x26 + x27 =1
x22’ + x2’4 + x2’5 + x2’6 + x2’7 =1
x13 + x34 + x35 + x36 + x37 =1
x14 + x24 + x2’4 + x34 + x45 + x46                         + x47 =1
x15 + x25 + x2’5 + x35 + x45 + x56                         + x57 =1
x16 + x26 + x2’6 + x36 + x46 + x56                         + x67 =1
x17 + x27 + x2’7 + x37 + x47 + x57                         + x67 =1
y12 + y13 = 2
y12 + y32 – y 23 = 1
y13 + y23 – y 32 = 1
xij ≥ 0 ykl ≥ 0

Lagrangean relaxation of RPP(GA):
Define variables µkl ≥0 associated to each constraint in (5) of RPP(GA).
The Lagrangean L(µ ) is:


(1)      minimize             ∑d x        ij ij   +          ∑                µkl ( ykl − (m − 1) ∗        ∑     xij )
                            {i , j}∈E A               k < l , k ,l ∈{1,.,m}                           (i∈Cl ∧ j∈Ck ) ∨
                                                                                                      ( j ∈Cl ∧i∈Ck )
s.t.



(2)         ∑x    +
                      ij   = 1, k ∈ V A
         {i , j}∈Ek




(3)        ∑y
           k <l
                  kl       = m −1


(4)       ∑y      kl       ≤ S − 1,           S ⊂ {1,..., m},1 < S < m
         k <l ,
         k ,l∈S


(5)       x ij ∈ {0,1}, {i, j} ∈ E A

(6)       y kl ∈ {0 ,1}, k < l, k , l ∈ {1,..., m}


This is the formulation that seems more interesting due to the fact that the two subproblems that arise are easy to solve,
a perfect matching and a spanning tree problems. In particular, in spite of the exponential number of constraints in the
spanning tree problem on the y variables, this problem is simple to solve using very well known algorithms such as
Prim´s or Kruskal’s.

For the problem example the Lagrangean Relaxation of RPP(GA) is:

Minimize 1x13 + 3x14 + 4x15 + 3x16 + 4x17 + 1x24 + 2x25 + 1x26 + 2x27 + 1x2’4 + 2x2’5 + 1x2’6
+ 2x2’7 +2x34 + 3x35 + 2x36 + 3x37 + 1x45 + 2x46 + 3x47 + 3x56 + 4x57 + 1x67
+ µ12 (y12 – (x 14 + x15 + x24 + x25 + x2’4 + x2’5 + x34 + x35))
+ µ13 (y13 – (x 16 + x17 + x26 + x27 + x2’6 + x2’7 + x36 + x37))
+ µ23 (y23 – (x 46 + x47 + x56 + x57))

s.t.

x13 + x14 + x15 + x16 + x17 =1
x22’ + x24 + x25 + x26 + x27 =1
x22’ + x2’4 + x2’5 + x2’6 + x2’7 =1
x13 + x34 + x35 + x36 + x37 =1
x14 + x24 + x2’4 + x34 + x45 + x46                        + x47 =1
x15 + x25 + x2’5 + x35 + x45 + x56                        + x57 =1
x16 + x26 + x2’6 + x36 + x46 + x56                        + x67 =1
x17 + x27 + x2’7 + x37 + x47 + x57                        + x67 =1
y12 + y13 + y23 = 2
y12 ≤ 1
y13 ≤ 1
y23 ≤ 1
xij ≥ 0 ykl ≥ 0


4. Comparison of models

In what follows we will compare the RPP(COR), RPP(GW) and RPP(GHI) models in order to show that RPP(GW) (or
its equivalent variants RPP(GR) and RPP(GA)) is a quite different model from RPP(COR) and RPP(GHI) models.

We say that a feasible solution x’ to RPP(COR) or RPP(GHI) is obtained from a feasible solution x of RPP(GW) if x’
is obtained from x by replacing each edge {k,l} of GA, with xkl =1 and R(k) ≠ R(l), with a path in the original graph
joining vertices k and l, and making x’e=1 for each edge e in that path. There is an infinite number of RPP(COR) feasible
solutions that can be obtained from a RPP(GW) feasible solution. However, some feasible solutions of RPP(COR) or
RPP(GHI) can not be obtained from a RPP(GW) feasible solution. For graph G=(V,E) in Figure 2, RPP(COR) has an
infinite number of feasible solutions, RPP(GHI) has two feasible solutions and RPP(GW) has a unique feasible solution
consisting of xkl = 1 for all {k,l} in EA. The sole feasible solution of RPP(COR) (or RPP(GHI)) that can be obtained
from the unique solution of RPP(GW) is the vector x=0.




                                                           Dashed edges represent a
                                                           RPP(GHI) feasible solution

                     G=(V.E)

                                          Figure 2

Any RPP(GHI) feasible solution is a RPP(COR) feasible solution. Figure 3 shows a graph G=(V,E) and a RPP(GW)
feasible solution x (dashed edges) such that the set of RPP(GHI) feasible solutions that can be obtained from x is
empty. So, RPP(GHI) and RPP(GW) are different models.


                                                                    -    Dark Edges are those in ER
                                                                    -    GS is equal to G (see section 2)
                      e                          e
                                                                    -    Dashed edges define a RPP(GW)
                                                                         feasible solution x
                                                                    −    Any RPP(COR) feasible solution
                                                                         x’ obtained from x has x’e
                                                                         ≥ 2. Therefore, x’ can not be a
                  G=(V,E)            RPP(GW) feasible solution x         RPP(GHI) feasible solution.

                                            Figure 3


5. Some new inequalities for RPP(GW)

Dominance relations are inequalities that reduce the set of feasible solutions to a smaller set which surely contains an
optimal solution. A valid inequality is an inequality satisfied by all feasible solutions. In this section we present some
new dominance relations and new valid inequalities for RPP(GW).
5.1. New Lemmas about the structure of some optimal solutions to RPP(GW)

In [6] Garfinkel&Webb present some lemmas on the structure of optimal solutions to RPP. All optimal solutions of
RPP(GW) satisfy some of these lemmas. In what follows we present some new structural properties of optimal
solutions which allow to obtain new dominance relations to RPP(GW).

Lemma 1: In an optimal solution, if two copies of (i,j) are in EP , with Ci ≠ Cj, then

                                                                 dij = min {dl k : l ∈ Ci, k ∈ Cj}.

Proof: If dij does not have minimum cost, the cost of the current solution can be improved by replacing the two copies
of (i,j) by two copies of the edge between Ci and Cj with minimun cost.                     •

Lemma 2: There is an optimal solution in which at most m-1 edges have two copies in EP .

Proof: Let EP be an optimal solution satisfying lemmas 1-11 in [6]. If k edges have two copies in EP and k > m-1, a pair
of these edges can be Euler-deleted without disconnecting (VR, ER∪EP ). Indeed, k-m+1 pairs of these edges can be
Euler-deleted without disconnecting (VR, ER∪EP ).                           •

Let GC=(VC,EC) be an auxiliary graph having, for every component Ci, a vertex vi, and for any pair of distinct components
Ci and Cj, an edge e={vi,vj} corresponding with a minimum cost edge e’ in ED between components Ci and Cj . We denote
e’ by eC(e). Let MST=(VT ,ET ) a minimum spanning tree on GC.

Lemma 3: There is an optimal solution in which all edges with two copies in EP must correspond only with edges in
MST, i.e., for each edge e’ with two copies in EP , there is an edge e in MST such that e C(e)= e’.

Proof: Let EP be an optimal solution satisfying lemmas 1-11 in [6] and lemmas 1 and 2. Let e be an edge between
components Ci and Cj, with two copies in EP . Then e is a bridge, i.e., the removal of its two copies from EP splits up the
solution into two non-intersecting Eulerian subtours containing Ci and Cj respectively. Let F be an edge-cut set between
these subtours. If e does not correspond to an edge in MST, there exists a unique path in MST from Ci to Cj. This path
has at least one edge e* traversing the edge cut-set F. From minimum spanning tree properties, d(e*) ≤ d(e).
Consequently, the solution obtained by replacing two copies of e by two copies of eC(e*), has a cost not greater than the
cost of the previous solution and the new solution can be modified in order to satisfy lemmas in [6] and lemmas 1 and 2.

We can repeat the above reasoning, starting with the last found solution, until every edge with two copies in EP
corresponds to an edge in MST.                                                  •


5.2. Inequalities for RPP(GW)

The following inequalities are dominance relations for RPP(GW):

(1) From lemmas 9 and 10 in [6]:

                 -                ∑x        kl      ≤ 2, i,j ∈ {1, ... , m}, i ≠   j
                         k ,l ∈V A , R ( k )∈Ci ,
                         d R ( R (k )) even,
                         R (l )∈C j


                     -        xkn + xlm ≤ 1,                            k,l,m,n ∈VA, R(k) ≠ R(l) ∈Ci, d(R(k)) even, d(R(l)) even,
                                                                 R(n),R(m)∈Cj, i,j ∈ {1, ... , m}, i ≠ j
                 -              ∑     x qr   + x kk ' ≤ 1         k∈ VA, k∈ Ci, d R(k) even, l≠n∈Cj, d R(l) or d R(n) even, i≠j
                           R( q )= k
                           R( r )= l or n


(2) From lemma 3, section 5.1: Let MST be as defined in section 5.1.

        If { k , l}∉ MST and d R (k) is even and d R (l) is even and Ck ≠ Cl then:

                                                     xkk’ + xk l + xk’ l + xk l’ + xk’l’ ≤ 1
                                                     xll’ + xk l + xk’ l + xk l’ + xk’l’ ≤ 1

The following are valid inequalities for RPP(GW) and its variants:

(3) Connectivity Inequalities (Corberán&al. [3]):
    Since (VR, ER∪EP ) has an Eulerian cycle, for J ⊂ {1, ... , m} the edge-cut set Ω(∪Cj:j∈J) has an even number of
    edges:

                          ∑x    kl    ≥ 2,
                 R (k )∈C j , j∈J
                          U
                 R (l )∉ Ci
                          i∈J



(4) Matching inequalities (Grötschel&Holland [7]):

                                          S −1
                          ∑x     kl   ≤
                                             2
                                                         , S⊂VR, |S| ≥ 3, |S| odd
                  R( k ),R (l )∈S ,
                  R( k )≠ R (l )


(5) The K-C inequalities (Corberán&Sanchis [2]) can be suitable adapted to RPP(GW):

    A K-C configuration is a partition {V0, … , VK} of VR, with K ≥ 3, such that :

    • V1, …, VK-1 and V0 ∪ VK are cluster of one or more R-sets,
    • ER(V0:VK) is positive and even,
    • E A (Vi A : V i A1 ) ≠ ∅ for i=0, … , K-1. Where EA(S:T) is the set of edges of EA with one end vertex in S and the
                      +

    other end vertex in T, Vi A is the union of Vi and {i’: i∈Vi with dR(i) even }

    The corresponding K-C inequality to RPP(GW) can be written as:

                          (K − 2) x ( E A (V0A : V KA )) +                  ∑ i − j x( E
                                                                      0≤ i < i ≤ K
                                                                                            A (Vi
                                                                                                    A
                                                                                                        : V jA )) ≥ 2(K − 1)
                                                                      (i , j ) ≠ (0 , K )




5.3. New valid inequalities for RPP(GW) obtained from a fractional optimal solution to the LP relaxation of
RPP(GW): The Even-Cycle inequalities

Figure 4 shows a fractional optimal solution to the LP relaxation of RPP(GW) (i.e. without integer constraints) that
satisfies inequalities 1 to 5 in section (5.2). In this section we introduce a new class of valid inequalities to RPP(GW),
the even-cycle inequalities, that allow to separate this kind of solutions.
                                                 2                                                             0.5

                                     1                      1                                       0.5                 0.5
                           10                2                                                               0.5
                     10          10                              10     10
                           10                               10
                                                     2                                                       0.5
                                                                 10
                                  1                                                             0.5                     0.5
                                                             1

                                              2                                                                0.5
Lemma 4: Let G = (V,E) be a graph and C ⊆ E a cycle with an even number of arcs.
1. C = M1∪M2, M1∩M2=∅, where M1 and M2 define two mathings in GC=(VC, E(VC)).
2. For any k≥1, k ≠ nC/2, any matching in GC, that contains k arcs of M1, contains at most (nC/2) - k-1 arcs of M2.

Proof:
1. Since C is a cycle, it can be partitioned in two sets of arcs, M1 and M2, that alternate in C. Since C is even, the two
    sets have the same number of arcs C/2=nC/2 where nC=VC.
2. Note that for a given k, k≥1, k ≠ nC, any combination of k arcs of M1 excludes at least k+1 arcs of M2 from any
    matching in VC. Since the number of arcs in M2 is nC/2, we have the result.

Remark: Statement 2 means, that for any feasible matching in G (the whole graph) that combines arcs of M1 and arcs of M2,
there are at least 2 nodes “covered” by arcs not in M1∪M2. Hence the solution has some additional arc incident with some
of the nodes of VC.

                                    •
                           •
                                             •
               •                                                               Arcs of M1
                                                      •                   Arcs of M2
                   •

                                                                                  The cycles
                       •                                                          continues
                                                  •
                               •            •
                                     •



6. Lower and Upper bounds to RPP

In this section we present a cutting plane algorithm (the MCK algorithm) and an heuristic (the Three-Tree heuristic) in
order to find lower and upper bounds to RPP respectively. The algorithms were tested with the same problem set as in
[2].

In [2], Corberán et al. present a cutting plane algorithm for RPP(COR) using non-negativity, connectivity, R-odd, K-
Component, Path-bridge and Honey Comb inequalities. Although this worked adequately for the instances tested, the
algorithm added a large number of cutting planes in general. The computational study on our algorithm (see Section 7)
shows that –on the average- very few cutting planes suffice to find a globally optimal solution and it suffices to
consider connectivity, matching and K-Component inequalities only. We took as the initial LP relaxation of our
algorithm the linear relaxation of RPP(GR) in order to reduce the number of flow variables.

In [9], Hertz et al. present construction and post-optimization heuristics to determine feasible solutions to RPP. Their
procedures are very sophisticated as compared with our heuristic that constructs an initial solution in the same way as
Frederickson’s and then applies a post-optimization procedure based on Euler-replacement and Euler-deletion
operations (see [6]). In general, the solution provided by our heuristic is optimal.


6.1. The Matching-Connectivity-K-C Cutting Plane Algorithm (or MCK algorithm)

(1) Let LP be the linear program having all the inequalities of RPP(GR) and all integer variables relaxed to real
    numbers. Go to Step (2).
(2) Let x* be the optimal solution of LP. Go to Step (3)
(3) If x* is integer (all its components are integer numbers) then go to step (9). Otherwise, go to Step (4).
(4) Look for some Matching and Connectivity inequalities violated by x* (if there exist violated inequalities, this step
    finds at least one them). Go to Step (5)
(5) If some violated inequalities have been found in step (4) then add all of them to LP and go to Step (2). Otherwise go
    to Step (6)
(6) Look for some KC inequalities violated by x* (this step is a heuristic algorithm, so it is possible that there exist
    KC inequalities violated by x* but this step does not find any). Go to Step (7)
(7) If a violated inequality has been found in Step (6) then add all such found inequalities to LP and go to Step (2).
    Otherwise, go to Step (8)
(8) If the objective function value VAL for x* is not integer then add to LP the inequality: objective function greater or
    equal to the nearest integer greater than VAL, and assign to x* the optimal sotution of LP. Go to Step (9)
(9) x* is the solution found by the MCK algoritm, STOP. (If x* is integer then we have obtained an optimal solution for
    the RPP problem whose model is RPP(GR))

Remarks:

-    The number of iterations of MCK is the number of times that step (2) is executed, that is the number of linear
    programs that are solved.

-    Explanation of Step (4):

    Let GA be the graph from which the RPP(GW) model has been formulated. Let Ci be the set of vertices of GA
    corresponding with the connected component i of GR.

    Given a proper vertex subset X of GA, the cut–edge set of GA corresponding with X will be denoted by Ω A(X). We
    say that Ω A(X) is an odd cut if the cardinality of X is odd. For a vertex set X, E(X) denotes the set of edges of GA
    having its two end vertices in X.
    A matching inequality is:                  ∑   x (e) ≤ ( X − 1) / 2
                                             e∈E ( X )
    where X is a proper subset of vertices of GA with odd cardinality and x(e) is the variable associated to edge e in
    RPP(GR).

    The above inequality is equivalent to the following inequality:     ∑ x(e) ≥ 1
                                                                      e∈Ω A ( X )
                                                                                     (see [8]).
A connectivity inequality is:     ∑ x(e) ≥ 2
                                e∈Ω A (U )

where Ω A(U) is a cut set and U is the union of some Ci’s.

We know that matching and connectivity inequalities are valid for RPP(GR).

There are two procedures for finding violated inequalities: one looks for violated Matching inequalities and the
other one looks for violated Connectivity inequalities. The two procedures are exact (not heuristics), in the sense
that if there is a violated Matching or Connectivity inequality then the respective procedure finds it.

As we will see later, more than one violated Matching and/or Connectivity inequality can be found at each iteration.
Let x* be the current optimal solution of LP. We say that the weight of edge e is x*(e). GA(x*) is the graph with the
same vertex set as GA and set of edges GA(x*) with those edges of GA having x*(e) not zero.

Separation procedure for the Matching Inequalities:

Let V1 denote the set of vertices of GA(x*) that are incident to an edge of GA(x*) with weight one. Remove, from
GA(x*), V1 and all edges incident to a vertex in V1. Denote the new graph by G’(x*). Clearly each minimum weighted
odd cut in G’(x*) determines a minimum weighted odd cut in GA(x*), and viceversa. (Note also that the number of
vertices of G’(x*) is even). So, x* violates a Matching inequality if and only if there is an odd cut with weight less
than one in the graph G’(x*).

The minimum cut values between each of the n(n-1)/2 pairs of vertices of a order n graph G can be represented by a
weighted tree T on n vertices called a Gomory-Hu tree, where for any pair of vertices (x,y), if e is the minimum
weigt edge on the path from x to y in T, then the minimum cut value between x and y in G is exactly the weigt of e.
Moreover, the two components of T-e form a minimum cut between x and y in G.

As shown by Padberg and Rao in [10] a minimum weighted odd cut of G’(x*) can be found by determining the
Gomory-Hu tree of G’(x*) and finding an edge of this tree having minimum capacity among those edges whose
removal splits the tree into two components of odd size.

Our procedure constructs a Gomory-Hu tree T. Then, for each edge e of T with weight less than one that defines an
odd cut, we take the set of vertices X of the component of T-e with minimum cardinality, and generate the following
violated Matching inequality:


   ∑ x( e) ≤ ( X
 e∈E ( X )
                   − 1) / 2      where       x(e)   is   the   variable   corresponding    with    e    in      RPP(GR)


Hence, it is possible to generate up to (n-1) violated Matching inequalities, where n is the order of G’(x*).


Separation procedure for the Connectivity Inequalities:

Let G’’(x*) be the graph obtained from GA(x*) by shrinking (or reducing) each Ci, 1 ≤i ≤m, into a vertex vi and
connecting vertex vi with vj by an edge with weight equal to the sum of the weights of edges in GA(x*) with an
extremity in Ci and the other extremity in Cj.

Our procedure constructs a Gomory-Hu tree T on G’’(x*) and for each edge e of T with weight less than two we take
the set of vertices X of the component of T-e with minimum cardinality, and generate the following violated
Connectivity inequality:
                                         ∑ x (e) ≥ 2
                                       e∈Ω A (U )

    where Ω A(U) is the cut set of GA associated to U (the union of the Ci for vi in X).

    Hence, it is possible to generate up to (n-1) violated Connectivity inequalities, where n is the order of G’(x*).

-   The heuristic algorithm looking for violated K-C inequalities in step (6) is similar to the one of Corberan el al.
    (see [2]). The heuristic of Corberán et al. has been adapted to cope with graph GA where even degree vertices in GR
    are duplicated in GA (see Section 3).

    In [2], given a R-set Ci, a vertex in Ci is called x*-external if it is connected to at least one vertex in a different R-
    set by an edge e with x*(e) > 0. In the first phase, Corberán et al. look for “ …an x*-external vertex u whose
    corresponding connected component in the subgraph has an even number of R-odd vertices…”. Instead, we first
    look for a x*-external vertex u whose corresponding connected component in the subgraph has two vertices (i.e., it
    corresponds with a R-even vertex of GR). If such a component does not exist, we look for components C in the
    subgraph with |V(C)|-[x*(Ω(C))] odd (i.e., with an odd number of vertices not matched. [x] means the greater
    integer less than x). Finally if there is not such a component we apply the criterion of Corberán et al. “… a
    component with an even number of R-odd vertices…”. In the second phase Corberán et al. “ …compute a spanning
    tree by iteratively adding the edge of maximum weight not forming a cycle… ”. We compute up to three such trees
    by modifying the criterion of adding edges in order to find a violated K-C inequality. The first tree is like in [2], the
    second tree is obtained by reversing the order of adding edges in [2], and finally, the third tree is the one with the
    longest path leaving from V0.

Now we will run the MCK algorithm on a simple RPP example in order to illustrate it:

RPP example:

number of vertices :   16
number of required edges :       12
number of non required edges :       19
solution value (including required edges costs):                                 963

required edges:

      v1     v2             weight                          v1     v2              weight
      1      2                32                             6      7                 21
      1      3                31                             8      9                 38
      1      4                71                             8     11                 20
      2      3                53                             9     10                 44
      5      6                69                             9     11                 21
      5      7                59                            12     13                 31

non-required edges:

    v1      v2             weight                           v1     v2              weight
     1       9               112                            16     12                111
     2       4                41                            16     13                 83
     2       8                94                             7     15                 65
     3       4                80                            10     11                 62
     3       5                38                            10     12                 92
     4       5               107                            10     14                 61
     6      16                13                            12     14                 32
     6      15                87                            13     14                 34
    16         7                     20                             13        15                 38
                                                                    14        15                 48

Cost of a minimum cost path between each pair of vertices:

C (1, 2) = 32           C (2, 7) = 150              C (3, 13) = 200           C (5, 12) = 190       C (8, 10) = 82
C (1, 3) = 31           C (2, 8) = 94               C (4, 5) = 107            C (5, 13) = 162       C (8, 11) = 20
C (1, 4) = 71           C (2, 9) = 132              C (4, 6) = 176            C (6, 7) = 21         C (8, 12) = 174
C (1, 5) = 69           C (2, 10) = 176             C (4, 7) = 166            C (6, 8) = 254        C (8, 13) = 177
C (1, 6) = 138          C (2, 11) = 114             C (4, 8) = 135            C (6, 9) = 235        C (9, 10) = 44
C (1, 7) = 128          C (2, 12) = 268             C (4, 9) = 173            C (6, 10) = 191       C (9, 11) = 21
C (1, 8) = 126          C (2, 13) = 253             C (4, 10) = 217           C (6, 11) = 253       C (9, 12) = 136
C (1, 9) = 112          C (3, 4) = 80               C (4, 11) = 155           C (6, 12) = 124       C (9, 13) = 139
C (1, 10) = 156         C (3, 5) = 38               C (4, 12) = 297           C (6, 13) = 96        C (10, 11) = 62
C (1, 11) = 133         C (3, 6) = 107              C (4, 13) = 269           C (7, 8) = 244        C (10, 12) = 92
C (1, 12) = 248         C (3, 7) = 97               C (5, 6) = 69             C (7, 9) = 218        C (10, 13) = 95
C (1, 13) = 231         C (3, 8) = 147              C (5, 7) = 59             C (7, 10) = 174       C (11, 12) = 154
C (2, 3) = 53           C (3, 9) = 143              C (5, 8) = 185            C (7, 11) = 236       C (11, 13) = 157
C (2, 4) = 41           C (3, 10) = 187             C (5, 9) = 181            C (7, 12) = 131       C (12, 13) = 31
C (2, 5) = 91           C (3, 11) = 164             C (5, 10) = 225           C (7, 13) = 103
C (2, 6) = 160          C (3, 12) = 228             C (5, 11) = 202           C (8, 9) = 38


Running MCK on the above problem:

In figures bellow, the dashed lines correspond with the current optimal solution x* (i.e. there is a dashed line e iff x*(e)
is not zero), the fractional values correspond with weights x*(e). The continuos lines correspond with the required
edges ER, they are designed in order to distinguish the connected components induced by the required edges. A dashed
loop on vertex a correspond with x*({a,a’}) =1.

Initially LP will be RPP(GR) relaxed to real variables.

Iteration number 1:

In step (2) we obtain the following optimal solution of LP (see figure 5):

X*[1   ,      4] = 0.75                      X*[4   ,   8’]   =   0.125                X*[9 , 10] = 0.791667
X*[1   ,      9] = 0.208333                  X*[5   ,   5']   =   0.75                 X*[10 , 12] = 0.166667
X*[1   ,      10] = 0.041667                 X*[6   ,   13]   =   0.083333             X*[11 ,11’] = 1.0
X*[2   ,      2'] = 1.0                      X*[6   ,   6']   =   0.916667             X*[12 , 13] = 0.833333
X*[3   ,      3'] = 0.75                     X*[7   ,   7’]   =   1.0                  X*[3' , 5] = 0.25
X*[3   ,      5'] = 0.25                     X*[8   ,   8’]   =   0.875                X*[6' , 13] = 0.08333
X*[4   ,      8] = 0.125                     X*[9   ,   10]   =   0.791667


                C0                                                       5’
                                                           0.25                0.75                 C1
                                     2       3      0.75
                                                                  0.25             5
                                         1
                                                    3’                             7     6
                      0.75
                                                                                                0.916..
                             4                                                                  .
                                                                                                  6’
                                                                                   0.083..
                0.125                                                              .          0.083..
                             0.125           0.0416..
                                                                                              .
                     0.875                   .
                8’                       0.2083
                             8
                                                                                          1
         C2                      9                                                        3
At step (4) the following three violated Matching inequalities are found:

-    For X ={4, 8, 8’} (Note that x*({4,8})+ x*({4,8’})+ x*({8,8’}) = 1.125 greater than (X-1)/2 )
     The corresponding violated inequality is x({4,8})+ x({4,8’})+ x({8,8’}) ≤ 1
-    For X ={6,6’,10,12,13} and
-    For X ={6,6’,13}

And the following three violated Connectivity inequalities are found:

-    The cut associated to C1 (whose weight is 0.666… and must be at least 2)
-    The cut associated to C2 (whose weight is 0.666… and must be at least 2)
-    The cut associated to C3 (whose weight is 0.333… and must be at least 2)

So, at first iteration three violated Matching inequalities and three violated Connectivity inequalities are added to LP in
step (5), and the algorithm indicates to jump to step (2) to begin iteration 2.

Iteration number 2:

In step (2) we obtain the following optimal solution of LP:

    X*[1,4] = 0.833333                X*[5,5']      =   0.166667            X*[10,12] = 1.0
    X*[1,9] = 0.166667                X*[6,6']      =   1.0                 X*[11,11'] = 1.0
    X*[2,2'] = 1.0                    X*[7,13]      =   0.166667            X*[3',5] = 0.833333
    X*[3,3'] = 0.166667               X*[7,7']      =   0.833333            X*[7',13] = 0.166667
    X*[3,5'] = 0.833333               X*[8,8']      =   1.0
    X*[4,9] = 0.166667                X*[9,13]      =   0.666667

At step (4) the following violated Matching inequality is found:

-    For X={7,7’,13}

And the following violated Connectivity inequality:

-    The cut set associated to C2 ∪ C3

So, at second iteration one violated Matching inequality and one violated Connectivity inequality are added to LP in step
(5), and the algorithm indicates to jump to step (2) to begin iteration 3.
Iteration number 3:

In step (2) we obtain the following optimal solution of LP:

X*[1   ,   4] = 0.5                 X*[5 , 5'] = 0.5                     X*[10     , 13] = 0.5
X*[1   ,   9] = 0.5                 X*[6 , 6'] = 1.0                     X*[11     ,11’] = 1.0
X*[2   ,   2'] = 1.0                X*[7 , 13] = 0.5                     X*[3'     , 5] = 0.5
X*[3   ,   3'] = 0.5                X*[7 , 7’] = 0.5                     X*[7’     , 12] = 0.5
X*[3   ,   5'] = 0.5                X*[8 , 8’] = 1.0
X*[4   ,   9] = 0.5                 X*[10 , 12] = 0.5

At step (4) the following violated Matching inequality is found:

-   For X={7, 7’, 12, 10, 13}

So, at third iteration one violated Matching inequality is added to LP in step (5), and the algorithm indicates to jump to
step (2) to begin iteration 4.

Iteration number 4:

In step (2) we obtain the following optimal solution of LP:

X*[1   ,   4] = 0.625               X*[5    ,   5']   =   0.5            X*[10     , 12] = 0.5
X*[1   ,   9] = 0.375               X*[6    ,   12]   =   0.25           X*[10     , 13] = 0.25
X*[2   ,   2'] = 0.875              X*[6    ,   6']   =   0.75           X*[11     ,11’] = 1.0
X*[2   ,   8’] = 0.125              X*[7    ,   13]   =   0.25           X*[2'     , 8’] = 0.125
X*[3   ,   3'] = 0.5                X*[7    ,   7’]   =   0.75           X*[3'     , 5] = 0.5
X*[3   ,   5'] = 0.5                X*[8    ,   8’]   =   0.75           X*[6'     , 13] = 0.25
X*[4   ,   8] = 0.25                X*[9    ,   10]   =   0.25           X*[7’     , 12] = 0.25
X*[4   ,   9] = 0.125               X*[9    ,   13]   =   0.25

At step (4) the following violated Matching inequalities are found:

-   For X={2, 2’, 8, 8’, 4}
-   For X={6, 6’, 7, 7’, 10, 12, 13}
-   For X={2, 2’, 8’}

So, at fourth iteration three violated Matching inequalities are added to LP in step (5), and the algorithm indicates to
jump to step (2) to begin iteration 5.

Iteration number 5:

In step (2) we obtain the following optimal solution of LP:

X*[1   ,   4] = 1.0                 X*[6    ,   12]   =   0.5            X*[10     , 12] = 0.5
X*[2   ,   8] = 0.5                 X*[6    ,   6']   =   0.5            X*[11     ,11’] = 1.0
X*[2   ,   2'] = 0.5                X*[7    ,   7’]   =   1.0            X*[2'     , 8’] = 0.5
X*[3   ,   3'] = 0.5                X*[8    ,   8’]   =   0.5            X*[3'     , 5] = 0.5
X*[3   ,   5'] = 0.5                X*[9    ,   10]   =   0.5            X*[6'     , 13] = 0.5
X*[5   ,   5'] = 0.5                X*[9    ,   13]   =   0.5

After executing step (4) we don’t obtain violated Matching inequalities neither violated Connectivity inequalities, the
algorithm indicates to jump to step (6). At step (6) the algorithm found three violated KC inequalities:
-   V0={2, 2’}, V1={8, 8’, 9 10, 11, 11’}, V2={12, 13}, V3={5, 5’, 6, 6’, 7, 7’}, V4={1, 3, 3’, 4}

    The violated KC inequality is:
               3
               ∑ x (Ω A (V0 ∪ V1 ∪ ... ∪Vi )) − 2 x ( E (V0 : V4 )) ≥ 6
              i=0

where:

- Ω A(X) denotes the cut set associated to vertex set X in graph GA
- x(F) denote the sum of variables corresponding with edges in F
- E(V:W) denote the set of edges with an incident vertex in V and the other incident vertex in W

-   V0={5, 5’}, V1={1, 3, 3’, 4, 2, 2’}, V2={8, 8’, 9 10, 11, 11’}, V3={12, 13}, V4={ 6, 6’, 7, 7’}
-   V0={8, 8’}, V1={1, 3, 3’, 4, 2, 2’}, V2={ 6, 6’, 7, 7’}, , V3={12, 13}, V4={9 10, 11, 11’}

So, at fifth iteration three violated KC inequalities are added to LP in step (7), and the algorithm indicates to jump to
step (2) to begin iteration 6.

Iteration number 6:

In step (2) we obtain the following optimal solution of LP:

X*[1     ,   4] = 0.5                   X*[4 , 9] = 0.5                   X*[11 ,11’] = 1.0
X*[1     ,   9] = 0.5                   X*[5 , 5'] = 1.0                  X*[3' , 7] = 0.5
X*[2     ,   2'] = 1.0                  X*[6 , 6'] = 1.0                  X*[7’ , 13] = 1.0
X*[3     ,   7] = 0.5                   X*[8 , 8’] = 1.0
X*[3     ,   3'] = 0.5                  X*[10 , 12] = 1.0

At step (4) the following violated Matching inequality is found:

-   For X={3, 3’, 7}. (Note that we could add a violated inequality for X={1, 4, 9}, the complement of X={3, 3’, 7} in
    G’(x*). We can modify the MCK algorithm to add this inequality but we don’t consider this possibility in order to
    not adding too much violated inequalities. In this particular example this inequality will be added in the next
    iteration but that is not the normal case.)

So, at sixth iteration one violated Matching inequality is added to LP in step (5), and the algorithm indicates to jump to
step (2) to begin iteration 7.

Iteration number 7:

In step (2) we obtain the following optimal solution of LP:
X*[1 , 4] = 0.5                     X*[4 , 9] = 0.5                       X*[10    ,   12] = 1.0
X*[1 , 9] = 0.5                     X*[5 , 5'] = 0.5                      X*[11    ,   11’] = 1.0
X*[2 , 2'] = 1.0                    X*[6 , 6'] = 1.0                      X*[3'    ,   5] = 0.5
X*[3 , 7] = 0.5                     X*[7 , 7’] = 0.5                      X*[5'    ,   13] = 0.5
X*[3 , 3'] = 0.5                    X*[8 , 8’] = 1.0                      X*[7’    ,   13] = 0.5

At step (4) the following violated Matching inequality is found:

-   For X={1,4,9}.
So, at seventh iteration one violated Matching inequality is added to LP in step (5), and the algorithm indicates to jump
to step (2) to begin iteration 8.

Iteration number 8:

In step (2) we obtain the following optimal solution of LP, shown in figure 6:

X*[1   ,   9] = 1.0                       X*[5    ,   5']   =   1.0           X*[10 , 12] = 1.0
X*[2   ,   2'] = 1.0                      X*[6    ,   6']   =   1.0           X*[11 , 11’] = 1.0
X*[3   ,   3'] = 1.0                      X*[7    ,   13]   =   1.0
X*[4   ,   7’] = 1.0                      X*[8    ,   8’]   =   1.0
              C0
                                                                                            C1
                                  2       3
                                                                          5
                                      1
                                                                          7     6

                          4




                          8
                                                                                 1
                              9                                                  3
                      1                                                                C3
            C2        1
                                                                      1
                                              1                       2
                                              0
                                                  Figure 6

At step (3) the solution is found to be integer. It jumps to step (9) and stop. We are found an optimal solution to the
RPP problem.


6.2. The Three_Tree Heuristic

Let x* be the solution found by the MCK Algorithm. Let GA(x*) be the graph with vertex set VA and edge set equal to all
edges e in EA with x*(e)>0.

For a subset of ED, F, GR[F] denotes the graph with vertex set {v1, v2, … , vm} (corresponding with sets V1, V2, … , Vm)
and edges e={vi, v j} iff i≠j and there is e’={v, w} ∈ F such that v ∈ Vi and w ∈Vj.

For a subset of EA, F, GRA[F] denotes the graph with vertex set {v1, v2, … , vm} (corresponding with sets V1, V2, … , Vm)
and edges e={vi, v j} iff i≠j and there is e’={v, w} ∈ F such that R(v) ∈ Vi and R(w) ∈Vj.


Tree_Euler_Reduction Heuristic (TER Heuristic):
Input: Graph G, set of required edges ER and an edge subset T ⊆ ED such that GR[T] is a tree and for every edge e={v,w}
in T if v ∈ Vi and w ∈ Vj then i ≠ j.
Output: A feasible solution E* to the RPP problem associated to G’=(V(G),E(G)∪ T) and ER∪T (i.e., E* is a multiset of
edges in ED such that GR∪P =(V, ER∪ T ∪E*) is eulerian)

(1) Apply Chinese Postman Problem Algorithm with input G and ER∪T. Let MCh be the matching returned by this
    algorithm.
(2) Apply Euler-Reduction Algorithm to the graph (V, MCh ∪ T).
    E* will be the reduced edge set returned by the Euler_Reduction algorithm.

The following heuristic utilizes the TER heuristic in order to obtain a feasible solution to the RPP problem associated
to G and ER.

Three_Tree Heuristic:

Input: graph G and set of required edges ER
Output: a feasible solution E* to the RPP problem associated to G and ER.

(1) Let x* be the solution returned by the MCK algorithm.
(2) If x* is integer then E* will be x* (note that x* will be an optimal solution to RPP) and Stop. Otherwise, go to Step
    (3).
(3) Find the three edge subsets T1, T2 and T3 of ED. Go to Step (4).
(4) For 1 ≤ i ≤ 3, let Ei* be the feasible solution returned by the TER algorithm with input G, ER, Ti. . Go to Step (5).
(5) Let E* be equal to the feasible solution with minimum cost among Ei*’s, 1 ≤ i ≤ 3. Stop.

Remarks:

(a) The Chinese Postman Problem Algorithm of J. Edmonds and E. Johnson (see[4]), solves (i.e., it returns an optimal
    solution) in polynomial time the RPP problem when the required edges set determines only one connected
    component. Note that the graph induced by ER ∪T in Step (1) has one connected component C. The solution given
    by the algorithm consists of a minimum cost perfect matching in the complete graph induced by the odd degree
    vertices of component C.

(b) The Euler_Reduction algorithm does Euler_deletion and Euler_replacement operations (see [6]) to a graph (V,F),
    where F is a subset of edges of ED such that GR[F] is connected.

    Euler_Reduction algorithm:

    Input: Graph (V,F), where F is a subset of edges of ED such that GR[F] is connected.
    Output: An edge subset E* of ED such that there are not two edges e={v,w} and e’={v’,w’} in E* with v=v’ such
    that (w=w’ and GR[E*-{e,e’}] is connected) or (w≠w’ and GR[E*∪{{w,w’}}\{e,e’}] is connected).

    (1) Find two edges e={v,w} and e’={v’,w’} with v=v’ such that (w=w’ and GR[F-{e,e’}] is connected) or (w≠w’
    and GR[F∪{{w,w’}}\{e,e’}] is connected).
    (2) If there are such edges e and e’ then:
         - if w=w’ set F = F-{e,e’} otherwise set F = F∪{{w,w’}}\{e,e’}
         - go to Step (1)
        Otherwise set E* = F and Stop.

(c) T1, T2, T3 are as follows:
    - T1 has minimum cost among all T⊆ ED such that GR[T] is a tree. When we apply the TER heuristic with input
         T1, the matching MCh that is obtained at Step (1) together with T1 is the Frederickson feasible solution to RPP
         (see [5]). After Step (2) is applied we will obtain in general a better feasible solution than the one of
         Frederickson.
     -   Define cost of edge e={v,w} of GA as the pair c(e) = (x*(e), dR(v),R(w) ). Let c(e)+c(e’) be defined as (x*(e) +
         x*(e’), dR(v),R(w) + d R(v’),R(w’)). For e={v,w} and e’={v’,w’} we say that c(e) is less than c(e’) iff (x*(e) > x*(e’))
         or ((x*(e) = x*(e’) and (dR(v),R(w) <d R(v’),R(w’)). Let TA be a minimum cost edge set of EA such that GRA[TA] is a
         tree. T2 is defined as {{R(v),R(w)}: {v,w} ∈ TA}.
     -   Define the cost of edge e={v,w} of GA as c(e) = dR(v),R(w) . Let TA be a minimum cost edge set of EA such that
         GRA[TA] is a tree. T3 is defined as {{R(v),R(w)}: {v,w} ∈ TA}.


An example that illustrates the Three_Tree Heuristic:

We have the following graph:

number of vertices : 19
number of required edges 17
number of non required edges                   27

Required edges:

v1        v2        cost                                 v1         v2       cost
1         2          3                                   7          9         1
2         3          1                                   8          9         5
2         4          5                                   10         11        2
3         4          4                                   10         12        3
5         6          2                                   13         14        6
5         8          4                                   14         15        4
6         7          6                                   14         16        3
7         8          3                                   17         18        9
                                                         18         19        2



Non required edges:

v1        v2        cost                                 v1         v2       cost
1         19         7                                   9          15        10
3         5          7                                   9          16        10
3         6          8                                   9          17        16
3         14         5                                   11         12        4
3         17         5                                   11         16        14
4         14         6                                   11         17        20
4         17         6                                   12         16        13
4         19         13                                  12         17        19
5         13         9                                   13         15        4
5         14         7                                   14         17        6
6         14         8                                   14         19        13
8         13         6                                   15         16        5
9         10         4                                   17         19        10
9         12         5
Cost of a minimum cost path between every pair of vertices:

C(1,2)=3           C(2,19)=10          C(5,8)=4            C(7,17)=17       C(11,13)=16
C(1,3)=4           C(3,4)=4            C(5,9)=8            C(7,18)=26       C(11,14)=17
C(1,4)=8           C(3,5)=7            C(5,10)=12          C(7,19)=25       C(11,15)=16
C(1,5)=11          C(3,6)=8            C(5,11)=14          C(8,9)=4         C(11,16)=14
C(1,6)=12          C(3,7)=14           C(5,12)=13          C(8,10)=8        C(11,17)=20
C(1,7)=18          C(3,8)=11           C(5,13)=9           C(8,11)=10       C(11,18)=29
C(1,8)=15          C(3,9)=15           C(5,14)=7           C(8,12)=9        C(11,19)=30
C(1,9)=19          C(3,10)=19          C(5,15)=11          C(8,13)=6        C(12,13)=15
C(1,10)=23         C(3,11)=21          C(5,16)=10          C(8,14)=11       C(12,14)=16
C(1,11)=25         C(3,12)=20          C(5,17)=12          C(8,15)=10       C(12,15)=15
C(1,12)=24         C(3,13)=11          C(5,18)=20          C(8,16)=14       C(12,16)=13
C(1,13)=15         C(3,14)=5           C(5,19)=18          C(8,17)=16       C(12,17)=19
C(1,14)=9          C(3,15)=9           C(6,7)=6            C(8,18)=24       C(12,18)=28
C(1,15)=13         C(3,16)=8           C(6,8)=6            C(8,19)=22       C(12,19)=29
C(1,16)=12         C(3,17)=5           C(6,9)=7            C(9,10)=4        C(13,14)=6
C(1,17)=9          C(3,18)=13          C(6,10)=11          C(9,11)=6        C(13,15)=4
C(1,18)=9          C(3,19)=11          C(6,11)=13          C(9,12)=5        C(13,16)=9
C(1,19)=7          C(4,5)=11           C(6,12)=12          C(9,13)=10       C(13,17)=12
C(2,3)=1           C(4,6)=12           C(6,13)=11          C(9,14)=13       C(13,18)=21
C(2,4)=5           C(4,7)=18           C(6,14)=8           C(9,15)=10       C(13,19)=19
C(2,5)=8           C(4,8)=15           C(6,15)=12          C(9,16)=10       C(14,15)=4
C(2,6)=9           C(4,9)=19           C(6,16)=11          C(9,17)=16       C(14,16)=3
C(2,7)=15          C(4,10)=23          C(6,17)=13          C(9,18)=25       C(14,17)=6
C(2,8)=12          C(4,11)=23          C(6,18)=21          C(9,19)=26       C(14,18)=15
C(2,9)=16          C(4,12)=22          C(6,19)=19          C(10,11)=2       C(14,19)=13
C(2,10)=20         C(4,13)=12          C(7,8)=3            C(10,12)=3       C(15,16)=5
C(2,11)=22         C(4,14)=6           C(7,9)=1            C(10,13)=14      C(15,17)=10
C(2,12)=21         C(4,15)=10          C(7,10)=5           C(10,14)=17      C(15,18)=19
C(2,13)=12         C(4,16)=9           C(7,11)=7           C(10,15)=14      C(15,19)=17
C(2,14)=6          C(4,17)=6           C(7,12)=6           C(10,16)=14      C(16,17)=9
C(2,15)=10         C(4,18)=15          C(7,13)=9           C(10,17)=20      C(16,18)=18
C(2,16)=9          C(4,19)=13          C(7,14)=14          C(10,18)=29      C(16,19)=16
C(2,17)=6          C(5,6)=2            C(7,15)=11          C(10,19)=30      C(17,18)=9
C(2,18)=12         C(5,7)=7            C(7,16)=11          C(11,12)=4       C(17,19)=10
                                                                            C(18,19)=2

Optimal solution x* obtained by the MCK algorithm:

Solution value       = 49.0

x*[1   ,   19]=      1.0        x*[6 , 6']=          7/8       x*[14   ,   15]=    1/4
x*[2   ,   5] =      1/2        x*[7 , 8] =          3/4       x*[14   ,   17]=    1/2
x*[2   ,   6] =      1/8        x*[7 , 12]=          1/4       x*[16   ,   17]=    1/4
x*[2   ,   17]=      1/4        x*[8 , 13]=          1/4       x*[18   ,   18']=   1.0
x*[2   ,   5']=      1/8        x*[9 , 11]=          3/4       x*[3'   ,   5]=     1/8
x*[3   ,   14]=      1/4        x*[9 , 9']=          1/4       x*[3'   ,   6']=    1/8
x*[3   ,   3']=      3/4        x*[10 , 10']=        1.0       x*[5'   ,   16]=    1/2
x*[4   ,   4']=      1.0        x*[11 , 16]=         1/4       x*[9'   ,   12]=    3/4
x*[5   ,   5']=      3/8        x*[13 , 15]=         3/4
In Figure 7, the dashed lines correspond with the optimal solution x*, there is a dashed line e iff x*(e) is not zero. The
continuos lines correspond with the required edges E . Required edges are designed in order to distinguish the
                                                        R
connected components induced by them. A dashed loop on vertex a correspond with x*( {a,a’} ) =1.

                                               4                     6’
                                                    3’
                              C0                                     6        C1
                                               3
                                                                     5
                                       2                             5’   8
                          1
                                                                                        7
                                                                          9        9’



                 1
                 9                                                                      1
                                                                                        2    C3
                                   1                         1                          1
           C5
                      1            7                         6                1         0
                      8                                          1            1
                                                      1
                                           C4         4          3
                                                           1
                                                           5
                                                     Figure 7
T1, T2 and T3 are respectively:

 T1:                                   T2:                                    T3:

 (   13, 8)                                (       2, 5)                       (    13, 8)
 (   9, 10)                                (       9, 12)                      (    9, 12)
 (   3, 14)                                (       17, 14)                     (    3, 14)
 (   3, 17)                                (       1, 19)                      (    2, 17)


For T1, T2, T3, the Matchings M1Ch , M2Ch , M3Ch obtained respectively by the Chinese Postman Problem Algorithm are:

Matching 1:                            Matching 2:                            Matching 3:

 (1,19)                                    (5,13)                              (1,19)
 (2,15)                                    (7,8)                               (3,15)
 (7,9)                                     (9,11)                              (7,9)
 (10,11)                                   (15,16)                             (11,16)
 (12,16)

And the respective three solutions Ei* to RPP, 1 ≤ i ≤ 3, returned by the Tree_Euler_Reduction algorithm are:
Solucion E1*:                        Solucion E2*:                      Solucion E3*:

    (12,16)                          (7,8)                                (2,17)
    (14,17)                          (9,12)                               (3,15)
    ( 13, 8)                         (14,17)                              (11,16)
    ( 7, 11)                         (15,16)                              ( 13, 8)
    ( 2, 15)                         ( 2, 5)                              ( 7, 12)
    ( 1, 19)                         ( 9, 11)                             ( 3, 14)
                                     ( 5, 13)                             ( 1, 19)
                                     ( 1, 19)

The Frederickson feasible solution is M1Ch ∪ T1 with cost 53 greater than 49 cost of E1*, so we have found a better
solution to RPP after applying the Euler_Reduction algorithm to the Frederickson solution. The reductions are the
followings: edges (3,14) and (3,17) are replaced by edge (14,17), and edges (7,9), (9,10) and (10,11) are replaced by
edge (7,11).

The costs of E2* and E3* are respectively 49 and 53.

So, the solution returned by the Three_Tree Heuristic is E1*.

(7) Computational Experience.

The MCK cutting plane algorithm and the Three-Tree heuristic have been coded in the C Language and run on a SUN
Sparc Station 10/30 with 4 HyperSparc at 100 MHz using only one processor. The CPLEX 4.0 library has been used to
solve LP problems. The algorithm has been tested on the same problem set than in [3] corresponding to 118 RPP
problems and 40 “genuine” GRP instances that were considered as RPP instances. Tables 11 to 15 show information
about the problems.

Tables 1 to 5 correspond to the MCK cutting plane results. The column headings are defined as follows:

-    Algorithm Value (MCK): Solution value of the MCK cutting plane algorithm. An “*” on an entry means that it was
                                necessary to append an extra inequality to enforce integrality of the objective value.
-    Optimal Value (OV):        Optimal solution value of the RPP instance. A dash before a number indicates that
                                the number is an upper bound of the optimal value.
-    MCK/OV:                    Solution value of the MCK cutting plane algorithm divided by the optimal solution
                                value.
-    Num. Match. Ineq. :        Number of identified violated Matching inequalities.
-    Num. Conn. Ineq. :         Number of identified violated Connectivity inequalities.
-    Num. K-C Ineq. :           Number of identified violated K-Component inequalities.
-    Total Num. Ineq.:          Total number of identified violated inequalities.
-    Time in Secs.:             CPU time in seconds.
-    Num. of Iter.:             Number of iterations.


In Tables 1 to 4 it can be seen that 113 out of 118 RPP instances were solve to optimality and among the other 5, 2 had
a MCK/OV ratio of 97% and the other 3 a ratio of 99%. The average number of identified violated inequalities in the
118 problems is 31. In Corberán et al. (see [2]) this average was 93, twice as much as ours. Thus, for these instances the
algorithm works extremely well.

When it comes to “genuine” GRP instances (Table 5), it can be seen that 31 of the 40 instances were solved to
optimality by the MCK algorithm and the average MCK/OV ratio for the other 9 instances was 98%. Note that, since we
don’t know the optimal value for these instances, OV is an upper bound, so the average MCK/(optimal value) is greater
than 98% and for some of them it may actually be equal to 1.
Tables 6 to 10 correspond to the Three-Tree heuristic results. The column headings are defined as follows:

-   Heur. Sol. (HS):     Solution value of the Three-Tree heuristic.
-   Time in Secs.:       CPU time in seconds.
-   Fred. Sol.: Solution value of the Frederickson’s heuristic.
-   Sol. Tree 1: Solution value returned by the Tree_Euler_Reduction algorithm for tree T1.
-   Sol. Tree 2: Solution value returned by the Tree_Euler_Reduction algorithm for tree T2.
-   Sol. Tree 3: Solution value returned by the Tree_Euler_Reduction algorithm for tree T3.
-   Opt.Value (OV):      Sptimal solution value for the RPP instance.
-   OV/HS:               (Sptimal value / Three-Tree heuristic solution value) ratio.

In Tables 6 to 9 it can be seen that 110 out of 118 RPP instances were solve to optimality and the other 10 had an
average OV/HS ratio of 95%. For some problems like P21, it could happen that the MCK algorithm produces a
fractionnal optimal solution and the Three-Tree heuristic was unable to produce a optimal solution.

When it comes to “genuine” GRP instances (Table 10), it will be seen that 20 of 40 instances were solved to optimality
by the Three-Tree algorithm and the average OV/HS ratio for the other 20 instances was 97%. Note that OV is a lower
bound for some of these instances, so the average (optimal value)/HS ratio is greater than 97%.

(8) Conclusions.

Our goal in this research work has been to explore the possibility of finding good lower and upper bounds for the RPP
using Garfinkel and Webb’s model RPP(GW) or its variants RPP(GR) and RPP(GA).

We have formulated the models RPP(GR) and RPP(GA) which are variants of RPP(GW). The number of y variables,
corresponding to flow or tree edges used to achieve connectivity of the solution, are considerably reduced in both
formulations.

It has been verified that the sets of feasible solutions to the RPP(GW) model as well as its variants are different to
those of [7] and [2].

We have formulated the Linear and the Lagrangean Relaxations of the three models: RPP(GW), RPP(GR) and
RPP(GA). We have designed programs in The C language, using CPLEX, for solving all three models, and we have
implemented the lagrangean program for RPP(GR). Classical subgradient optimization has been used to solve the
multiplier problem in the Lagrangean Relaxation. The bounds obtained so far are not better than those of [2] or [3].
Moreover, the values for the Lagrangean relaxation are generally quite close to those of the linear relaxation. This leads
us to believe that the existing gap between the Lagrangean relaxation and the optimal solution may be quite big.
However, we know that in general, the values of the linear and Lagrangean relaxations are not the same and some
heurisitcs should be investigated to obtain good lagrangean multipliers.

The computational results given in Section 7 show that our MCK cutting plane algorithm and our Three-Tree heuristic
are capable of solving almost all instances to proven optimality. There is still room for improvement in our algorithms,
specially reducing CPU time. For the MCK algorithm, one improvement would be the addition of heuristic separation
algorithms for Matching and Connectivity inequalities in order to decrease the running time. Another improvement
would be the reduction of variables when solving the LP problems in each iteration. This can be accomplished by
adopting a scheme of column addition as presented in [8]. For the Three-Tree algorithm, it would be necessary to
replace the algorithm used to solve the Chinese Rural problem by a specialized one (we have utilized the CPLEX library
to solve that problem).



Acknowledgements: This research was partially funded by the Spanish Agency of Iberoamerican Cooperation
(A.E.C.I.). Part of this work was carried out while the second author was on sabbatical leave at Polytechnique University
of Catalunya, Spain. This support is gratefully acknowledged. The authors want to thank Angel Corberán and Alain Hertz
for providing us their instance sets.

References.

[1] A. Corberán, J.M. Sanchis. “A Polyhedral approach to the Rural Postman Problem”. European Journal of Op. Res.
vol. 79, 95-114. 1994.

[2] A. Corberán, A. Letchford, J. M. Sanchis. “A Cutting Plane Algorithm for the General Routing Problem”. Personal
communication. Nov. 1998.

[3] N. Christofides, V. Campos, A. Corberán, E. Mota. "An Algorithm for the Rural Postman problem". Imperial College
Report IC.O.R.81.5. 1981.

[4] J. Edmonds, E.L. Johnson. “Matchings, Euler Tours and the Chinese Postman”. Mathematical Programming, 5, 88-
124.

[5] G.N. Frederickson. “Approximation algorithms for some Postman problems”. Journal for the Association for
Computing Machinery, 7, 178-193. 1979

[6] R. Garfinkel, I. Webb. “On Crossings, the Crossing Postman Problem, and the Rural Postman Problem”. To appear in
Networks.

[7] G. Ghiani, G. Laporte. “ A branch-and-cut algorithm for the undirected rural postman problem”. Center for research
on Transportation. Universidad de Montréal. Report CRT-97-54. Dec. 1997.

[8] M. Grötschel, O. Holland. “Solving Matching Problems with Linear Programming”. Mathematical Programming, vol.
33, 243-259, 1985

[9] A. Hertz, G. Laporte, P. Nanchen. “Improvement procedures for the undirected rural postman problem”. Working
paper. Center for Research on Transportation, Univ. Montréal. 1996

[10] M.W. Padberg, M.R. Rao, “Odd Minimum Cut-Sets and b-Matchings”. Mathematics of Operations Research 7, 67-
80, 1982.
           Number of      Number of     Number of   Number of
           vertices of    vertices of    R-sets      R-even
           the original       GR                     vertices
             graph
ALBAIDAA      102            102           10          42
ALBAIDAB       90            90            11          52
   P01         11            11             4           3
   P02         14            14             4           6
   P03         28            28             4          18
   P04         17            17             3          11
   P05         20            20             5          10
   P06         24            24             7          10
   P07         23            23             3           9
   P08         17            17             2           7
   P09         14            14             3           6
   P10         12            12             4           8
   P11         9              9             3           5
   P12         7              7             3           3
   P13         7              7             3           1
   P14         28            28             6          14
   P15         26            26             8           8
   P16         31            31             7          19
   P17         19            19             5           7
   P18         23            23             8           5
   P19         33            33             7           9
   P20         50            50             7          32
   P21         49            49             6          29
   P22         50            50             6          28
   P23         50            50             6          30
   P24         41            41             7          23


                     Table 1
              Number of      Number of     Number of   Number of
              vertices of    vertices of    R-sets      R-even
              the original       GR                     vertices
                graph
RANDOMPR_0        20              6            3          0
RANDOMPR_1        20              8            4          0
RANDOMPR_2        20              7            3          1
RANDOMPR_3        20             11            4          1
RANDOMPR_4        20              9            3          3
RANDOMPR_5        30             11            4          3
RANDOMPR_6        30             14            4          2
RANDOMPR_7        30             12            5          2
RANDOMPR_8        30             16            5          4
RANDOMPR_9        30             17            6          5
RANDOMPR_10       40             21            8          3
RANDOMPR_11       40             16            6          2
RANDOMPR_12       40             13            5          1
RANDOMPR_13       40             25            9          7
RANDOMPR_14       40             24            7          4
RANDOMPR_15       50             27            8          7
RANDOMPR_16       50             27           12          3
RANDOMPR_17       50             19            6          5
RANDOMPR_18       50             26            7          8
RANDOMPR_19       50             27            8          9

                       Table 2
              Number of      Number of     Number of   Number of
              vertices of    vertices of    R-sets      R-even
              the original       GR                     vertices
                graph
GRIDPROB_0        16             6             3           0
GRIDPROB_1        16            10             5           0
GRIDPROB_2        16             8             4           0
GRIDPROB_3        16            13             5           3
GRIDPROB_4        16            12             5           2
GRIDPROB_5        16             9             3           5
GRIDPROB_6        16            16             4          10
GRIDPROB_7        16            12             4           4
GRIDPROB_8        16            12             4           6
GRIDPROB_9        36            18             7           4
GRIDPROB_10       36            22             9           4
GRIDPROB_11       36            24             9           4
GRIDPROB_12       36            33             7          13
GRIDPROB_13       36            27             6           7
GRIDPROB_14       36            31             7           7
GRIDPROB_15       36            34             5          16
GRIDPROB_16       36            33             7          13
GRIDPROB_17       36            35             5          15
GRIDPROB_18       64            34            10           8
GRIDPROB_19       64            39            12          13
GRIDPROB_20       64            41            14          11
GRIDPROB_21       64            49             8          23
GRIDPROB_22       64            55             8          27
GRIDPROB_23       64            58            11          18
GRIDPROB_24       64            62             4          32
GRIDPROB_25       64            60             5          26
GRIDPROB_26       64            61             6          35
GRIDPROB_27      100            60            19          12
GRIDPROB_28      100            68            20          26
GRIDPROB_29      100            64            20          18
GRIDPROB_30      100            82            13          30
GRIDPROB_31      100            92            18          38
GRIDPROB_32      100            91            11          37
GRIDPROB_33      100            97             4          39
GRIDPROB_34      100            100            9          42
GRIDPROB_35      100            97             6          45



                      Table 3
              Number of      Number of     Number of   Number of
              vertices of    vertices of    R-sets      R-even
              the original       GR                     vertices
                graph
DEGREE4P_0        16             5             2           1
DEGREE4P_1        16             9             3           3
DEGREE4P_2        16            12             4           6
DEGREE4P_3        16            10             3           4
DEGREE4P_4        16            11             4           5
DEGREE4P_5        16            13             4           7
DEGREE4P_6        16            14             5           6
DEGREE4P_7        16            14             4           6
DEGREE4P_8        16            16             4           8
DEGREE4P_9        36            20             8           4
DEGREE4P_10       36            17             7           3
DEGREE4P_11       36            28            11           4
DEGREE4P_12       36            25             8           9
DEGREE4P_13       36            26             5          14
DEGREE4P_14       36            35             9          11
DEGREE4P_15       36            33             6          15
DEGREE4P_16       36            34             4          16
DEGREE4P_17       36            36             6          12
DEGREE4P_18       64            43            15           7
DEGREE4P_19       64            40            11          12
DEGREE4P_20       64            37            11           9
DEGREE4P_21       64            56            10          20
DEGREE4P_22       64            57            12          19
DEGREE4P_23       64            55             9          17
DEGREE4P_24       64            61             6          25
DEGREE4P_25       64            61             9          29
DEGREE4P_26       64            62             5          30
DEGREE4P_27      100            70            22          22
DEGREE4P_28      100            70            19          22
DEGREE4P_29      100            68            20          14
DEGREE4P_30      100            88            13          46
DEGREE4P_31      100            86            10          34
DEGREE4P_32      100            88            16          36
DEGREE4P_33      100            100            9          56
DEGREE4P_34      100            95             9          47
DEGREE4P_35      100            96             9          44


                      Table 4
                     Number of      Number of     Number of   Number of
                     vertices of    vertices of    R-sets      R-even
                     the original       GR                     vertices
                       graph
          ALBA_3_1      116            72            22          18
          ALBA_3_2      116            68            23          14
          ALBA_3_3      116            59            15          23
          ALBA_3_4      116            70            21          22
          ALBA_3_5      116            73            19          25
          ALBA_5_1      116            101           18          33
          ALBA_5_2      116            100           14          42
          ALBA_5_3      116            99            11          49
          ALBA_5_4      116            91             8          41
          ALBA_5_5      116            102           16          42
          ALBA_7_1      116            104            6          40
          ALBA_7_2      116            108            2          52
          ALBA_7_3      116            110            9          50
          ALBA_7_4      116            110            4          44
          ALBA_7_5      116            110            7          52
            GRP1        116            94            34          24
            GRP2        116            94            30          34
            GRP3        116            95            34          27
            GRP4        116            85            17          83
            GRP5        116            92            21          30
            GRP6        116            110            4          48
            GRP7        116            78            26          24
            GRP8        116            89            20          33
            GRP9        116            64             8          26
           GRP10        116            85            17          85
          MADR_3_1      196            127           42          31
          MADR_3_2      196            142           34          56
          MADR_3_3      196            137           36          41
          MADR_3_4      196            140           39          42
          MADR_3_5      196            131           38          43
          MADR_5_1      196            176           21          68
          MADR_5_2      196            174           25          74
          MADR_5_3      196            165           22          71
          MADR_5_4      196            166           23          74
          MADR_5_5      196            169           26          73
          MADR_7_1      196            188            7          92
          MADR_7_2      196            192            2          72
          MADR_7_3      196            191            6          99
          MADR_7_4      196            192            3          94
          MADR_7_5      196            191            3          85


Table 5
                                                                                               39




                        Algorithm   Optimal          Num. Num.             Num.     Total
                          Value     Value     MCK/OV Match. Conn.           K-C     Num.    Time in Num.
                         (MCK)       (OV)            Ineq. Ineq.           Ineq.    Ineq.   Secs. Of Iter.
     ALBAIDAA             3304       3304       1      99    10               0      109     64.93   45
     ALBAIDAB             2826       2826       1      37    10               0       47     42.31   12
     P01                   51          51       1       1     3               0        4     0.06     2
     P02                   72          72       1       4     5               3       12     0.15     5
     P03                   29          29       1       3     4               0        7     0.43     4
     P04                   29          29       1       1     3               2        6     0.16     4
     P05                   55          55       1       2     6               2       10     0.41     5
     P06                   32          32       1       5     3               0        8      0.3     3
     P07                   37          37       1       1     2               0        3     0.12     2
     P08                   29          29       1       2     1               0        3     0.08     3
     P09                   26          26       1       3     3               0        6      0.1     4
     P10                   35          35       1       8     4               0       12     0.15     7
     P11                    9          9        1       2     3               0        5     0.05     3
     P12                    6          6        1       0     1               0        1     0.04     2
     P13                   23          23       1       0     2               0        2     0.04     2
     P14                   57          57       1      31    14               4       49     2.21    10
     P15                   261        261       1      12    10               0       22     0.85     4
     P16                   64          64       1      34    13               9       56     5.92    17
     P17                   49          49       1      20     6               2       28     0.65    11
     P18                   85          85       1       7     9               0       16     0.39     3
     P19                   116        116       1       6     7               0       13     0.81     3
     P20                   116        116       1      73    11               6       90     23.13   19
     P21                   78*         78       1      43    10              13       66     84.32   23
     P22                   122        122       1      17    10               3       30     5.92     9
     P23                   95          95       1      54     9              11       74     22.99   29
     P24                  113*        113       1      38    10               3       51     6.06    11


Table 6: Computational results of the MCK algorithm for the Christofides&al (1981) and
Corberán&Sanchis (1994) instances.
                                                                                              40




                         Algorithm   Optimal          Num. Num.             Num.    Total
                           Value     Value     MCK/OV Match. Conn.           K-C    Num.    Time in Num.
                          (MCK)       (OV)            Ineq. Ineq.           Ineq.   Ineq.   Secs. Of Iter.
     RANDOMPR_0           20716      20716       1      1      2              0        3     0.04    2
     RANDOMPR_1           23136      23136       1      2      3              0        5     0.04    2
     RANDOMPR_2           14677      14677       1      1      2              0        3     0.03    2
     RANDOMPR_3           16576      16576       1      1      2              0        3     0.05    2
     RANDOMPR_4            7552       7552       1      1      1              0        2     0.04    2
     RANDOMPR_5           20459      20459       1      1      3              0        4     0.05    2
     RANDOMPR_6           16902      16902       1      1      2              0        3     0.05    2
     RANDOMPR_7           20729      20729       1      2      3              0        5     0.07    2
     RANDOMPR_8           23974      23974       1      4      3              0        7     0.08    2
     RANDOMPR_9           19425      19425       1      6      5              0       11      0.2    5
     RANDOMPR_10          16850      16850       1      6      7              0       13     0.27    2
     RANDOMPR_11          27413      27413       1      7      8              0       15     0.19    5
     RANDOMPR_12          39240      39240       1      5      4              0        9     0.09    3
     RANDOMPR_13          19707      19707       1      8      6              0       14     0.63    6
     RANDOMPR_14          23391      23391       1      9      7              0       16     0.52    8
     RANDOMPR_15          23193      23193       1      9      8              0       17     1.06    7
     RANDOMPR_16          30960      30960       1      5     11              0       16     0.53    3
     RANDOMPR_17          27311      27311       1      6      5              0       11     0.13    2
     RANDOMPR_18          21209      21209       1      3      5              0        8     0.31    3
     RANDOMPR_19          13640      13640       1      7      4              0       11     0.71    4


Table 7: Computational results of the MCK algorithm for Class 1 RPP random instances from
Hertz&al. (1998).
                                                                                               41




                       Algorithm   Optimal           Num. Num.            Num.    Total
                         Value     Value     MCK/OV Match. Conn.           K-C    Num.      Time in Num.
                        (MCK)       (OV)             Ineq. Ineq.          Ineq.   Ineq.     Secs. Of Iter.
     GRIDPROB_0            9          9         1       0     2              0       2       0.04     2
     GRIDPROB_1            9          9         1       2     6              0       8       0.08     4
     GRIDPROB_2            8          8         1       3     4              0       7       0.06     3
     GRIDPROB_3            8          8         1       0     4              0       4       0.08     2
     GRIDPROB_4            7          7         1       3     5              0       8       0.09     4
     GRIDPROB_5            5          5         1       3     2              0       5       0.07     4
     GRIDPROB_6            7          7         1       7     5              5      17       0.43     9
     GRIDPROB_7            6          6         1       3     5              0       8       0.08     4
     GRIDPROB_8            7          7         1       5     3              0       8        0.1     4
     GRIDPROB_9           11         11         1       5     8              0      13       0.26     4
     GRIDPROB_10          15         15         1      10    15              0      25       0.61     5
     GRIDPROB_11          15         15         1      11    12              0      23       0.74     7
     GRIDPROB_12          14         14         1      16    10              0      26       1.13     5
     GRIDPROB_13          17         17         1      31     7              2      40       1.09    11
     GRIDPROB_14          17*        17         1      18    10              3      31       6.69    10
     GRIDPROB_15          13         13         1       7     6              0      13       0.68     3
     GRIDPROB_16          16         16         1      27     7              3      37       2.52    13
     GRIDPROB_17          14         14         1       8     4              0      12        0.6     3
     GRIDPROB_18          22         22         1      11    10              0      21        1.2     3
     GRIDPROB_19          23         23         1      86    21              0     107       13.22   17
     GRIDPROB_20          25         25         1      41    25              2      68        6.7    15
     GRIDPROB_21          22         22         1      76     9              5      90       24.59   25
     GRIDPROB_22          19         19         1       5     4              0       9        2.8     3
     GRIDPROB_23          24         24         1      17    16              0      33       5.01     6
     GRIDPROB_24          22         22         1      22     3              0      25       4.61    11
     GRIDPROB_25          21         21         1      17     7              0      24       2.41     6
     GRIDPROB_26          16         16         1      11     5              0      16       2.86     4
     GRIDPROB_27          37         37         1      97    44              6     147       73.12   23
     GRIDPROB_28          35         35         1      89    29              0     118       31.79   13
     GRIDPROB_29          38         38         1      91    33              1     125       25.19   10
     GRIDPROB_30          37         37         1      61    26              2      89       31.74   12
     GRIDPROB_31          37         37         1      69    27              0      96       78.28   12
     GRIDPROB_32          37*        38      0.97368   93    18             11     122       64.51   26
     GRIDPROB_33          35         35         1      16     3              0      19       6.69     3
     GRIDPROB_34          37*        37         1      73     8              1      82       32.17   11
     GRIDPROB_35          33         33         1      36     4              0      40       20.54   19


Table 8: Computational results of the MCK algorithm for Class 2 RPP random instances from
Hertz&al. (1998).
                                                                                               42




                       Algorithm   Optimal           Num. Num.            Num.    Total
                         Value     Value     MCK/OV Match. Conn.           K-C    Num.      Time in Num.
                        (MCK)       (OV)             Ineq. Ineq.          Ineq.   Ineq.     Secs. Of Iter.
     DEGREE4P_0           153        153        1       0     1              0       1       0.02     2
     DEGREE4P_1           451        451        1       4     2              0       6       0.06     4
     DEGREE4P_2           380        380        1       3     6              0       9        0.1     4
     DEGREE4P_3           411        411        1       2     2              0       4       0.04     2
     DEGREE4P_4           521        521        1       5     4              0       9       0.08     3
     DEGREE4P_5           473        473        1      10     4              3      17       0.22     8
     DEGREE4P_6           504        504        1       8     5              0      13       0.21     6
     DEGREE4P_7           457        457        1       1     3              0       4       0.08     2
     DEGREE4P_8           399        399        1      19     5              3      27       0.36    10
     DEGREE4P_9           666        666        1       8    12              0      20       0.44     4
     DEGREE4P_10          488        488        1       8    11              0      19       0.27     4
     DEGREE4P_11          459        459        1       8    14              0      22       0.84     3
     DEGREE4P_12          571        571        1       6     9              0      15       0.56     3
     DEGREE4P_13          347        347        1       7     4              0      11       0.72     8
     DEGREE4P_14          458        458        1       7     7              0      14       0.83     2
     DEGREE4P_15          492        492        1       6     6              0      12       0.74     4
     DEGREE4P_16          354        354        1      31     5              3      39         2     12
     DEGREE4P_17          448        448        1      11     5              0      16       1.25     7
     DEGREE4P_18          547        547        1      11    14              0      25        1.7     5
     DEGREE4P_19          644        644        1      20    21              0      41       2.87     4
     DEGREE4P_20          569        569        1       4     9              0      13       1.08     2
     DEGREE4P_21          451        451        1      11     9              0      20       4.59     3
     DEGREE4P_22          589        607     0.97035   20    13              0      33       4.68     6
     DEGREE4P_23          600        600        1       9     8              0      17       3.31     4
     DEGREE4P_24          465        465        1      10     4              0      14       2.46     5
     DEGREE4P_25          515        515        1      30     9              0      39       8.96     7
     DEGREE4P_26          573        573        1       5     4              0       9       1.64     2
     DEGREE4P_27         870*        872     0.99771  103    56              3     162      143.17   13
     DEGREE4P_28          780        780        1      44    32              0      76       16.6     6
     DEGREE4P_29         841*        846     0.99409  100    36              4     140       61.35   16
     DEGREE4P_30          722        722        1      60    17              0      77       81.91   23
     DEGREE4P_31          739        739        1      18     8              0      26        9.7     4
     DEGREE4P_32          659        659        1      59    21              0      80      118.77   32
     DEGREE4P_33         746*        752     0.99202  158    15             15     188      405.78   34
     DEGREE4P_34          683        683        1      21     8              0      29       13.51    6
     DEGREE4P_35          638        638        1      29    14              0      43       34.23   15


Table 9: Computational results of the MCK algorithm for Class 3 RPP random instances from
Hertz&al. (1998).
                                                                           43




           Algorithm   Optimal           Num. Num.     Num.    Total
             Value     Value     MCK/OV Match. Conn.    K-C    Num.    Time in Num.
            (MCK)       (OV)             Ineq. Ineq.   Ineq.   Ineq.    Secs. Of Iter.
ALBA_3_1     3542       3542        1      80    30       0     110     68.07   20
ALBA_3_2     3607*     -3610     0.99917  156    36       0     192     80.58   21
ALBA_3_3     3576       3576        1      57    20       0      77     26.68   26
ALBA_3_4     3639*     -3644     0.99863  120    31       2     153    138.28   29
ALBA_3_5     3313       3313        1      51    26       0      77     32.64   12
ALBA_5_1     4289       4289        1     183    24       0     207    336.14   61
ALBA_5_2     3820       3820        1     139    14       0     153    209.49   69
ALBA_5_3     3126       3126        1      42    12       0      54     35.43   11
ALBA_5_4     2987       2987        1      19     4       0      23     12.96   19
ALBA_5_5     3196       3196        1      81    23       0     104    152.23   26
ALBA_7_1     3281       3281        1     260     5       0     265    119.44    xx
ALBA_7_2     2580       2580        1      22     1       0      23     3.37    13
ALBA_7_3     3239       3239        1     225    10       0     235     287.2   137
ALBA_7_4     3126       3126        1     147     2       0     149     53.14   98
ALBA_7_5     3433       3433        1      45     6       0      51     24.77   27
  GRP1       4214       4214        1      45    43       0      88    122.82    xx
  GRP2       3872*     -3884     0.99691  705    49       0     754      xx     203
  GRP3       4199*      4199        1      49    55       0     104    120.98    5
  GRP4       2717*      2717        1      38    34     100     172    1789.94  30
  GRP5       3284       3284        1      47    20       0      67     54.95    3
  GRP6       2702       2702        1       4     3       0       7     5.62     3
  GRP7       3682       3682        1      20    27       0      47     37.3     4
  GRP8       4316       4316        1      61    40       0     101     77.64    4
  GRP9       2292       2292        1      21     1       0      22     6.48    20
 GRP10       2668*     -2808     0.95014   15    33      90     138    1224.74  24
MADR_3_1     4906*     -5110     0.96008  198    70       5     273    2047.28  22
MADR_3_2     5439*     -5470     0.99433  141    25       9     175    729.68   25
MADR_3_3     5338*     -5445     0.98035  306    63       1     370    1714.22  22
MADR_3_4     5395*     -5570     0.96858  177    59       0     236    1610.54  14
MADR_3_5     4928*     -5050     0.97584  187    66       5     258    1466.96  26
MADR_5_1     4150       4150        1      33    13       0      46     97.96    6
MADR_5_2     4930       4930        1     105    38       0     143    504.02   27
MADR_5_3     4170       4170        1     276    23       8     307    1723.27  51
MADR_5_4     4640       4640        1      50    16       0      66    570.95   22
MADR_5_5     4760       4760        1      84    26       0     110    1049.21  20
MADR_7_1     4655       4655        1      12     6       0      18     93.64    6
MADR_7_2     4615       4615        1      20     1       0      21     37.47   13
MADR_7_3     4505       4505        1      18     4       0      22     18.36    7
MADR_7_4     3815       3815        1      13     2       0      15     14.46    6
MADR_7_5     4525       4525        1      18     2       0      20     42.79    8
                                                                                                    44



Table 10: Computational results of the MCK algorithm for the “genuine” GRP instances from
                                    Corberán&al. (1998)




                                 Heur.                                           Opt.
                                  Sol.   Time in    Fred.    Sol.   Sol.   Sol.  Value
                                 (HS)     Secs.     Sol.    Tree 1 Tree 2 Tree 3 (OV) OV/HS
               ALBAIDAA          3304      70.5     3304     3304     3392     3392    3304        1
               ALBAIDAB          2826      51.2     2826     2826     2862     2862    2826        1
                  P01             51       0.15      51       51       51       51      51         1
                  P02             72       0.23      73       73       72       72      72         1
                  P03             29       0.5       29       29       29       29      29         1
                  P04             29       0.22      29       29       29       29      29         1
                  P05             55       0.64      61       61       55       55      55         1
                  P06             32       0.53      37       37       32       32      32         1
                  P07             37       0.2       37       37       37       37      37         1
                  P08             29       0.14      29       29       29       29      29         1
                  P09             26       0.16      26       26       26       26      26         1
                  P10             35       0.24      35       35       35       35      35         1
                  P11             9        0.07       9        9        9        9       9         1
                  P12             6        0.05       8        6        6        6       6         1
                  P13             23       0.06      23       23       23       23      23         1
                  P14             57       2.59      60       60       57       57      57         1
                  P15            261       1.51      265      261      261      261     261        1
                  P16             64       7.7       75       71       64       64      64         1
                  P17             49       1.15      53       49       49       53      49         1
                  P18             85       0.8       85       85       85       85      85         1
                  P19            116       1.23      133      133      116      116     116        1
                  P20            116      27.54      120      118      116      116     116        1
                  P21             81      35.72      84       84       81       84      78       0.963
                  P22            122       6.4       134      123      122      122     122        1
                  P23             95      27.91      97       95       95       95      95         1
                  P24            113       7.61      125      118      114      113     113        1

Table 11: Computational results of the Three-Tree heuristic for the Christofides&al (1981) and
Corberán&Sanchis (1994) instances.
                                                                                                    45




                                Heur.                                          Opt.
                                 Sol.   Time in   Fred.    Sol.   Sol.   Sol.  Value
                                (HS)     Secs.    Sol.    Tree 1 Tree 2 Tree 3 (OV) OV/HS
            RANDOMPR_0         20716     0.12     20875   20875    20716    20716   20716      1
            RANDOMPR_1         23136     0.21     23136   23136    23136    23136   23136      1
            RANDOMPR_2         14677     0.14     15709   15709    14677    14677   14677      1
            RANDOMPR_3         16576     0.23     16788   16576    16576    16576   16576      1
            RANDOMPR_4          7552     0.16     10259   10180    7552     7552    7552       1
            RANDOMPR_5         20459     0.22     20459   20459    20459    20459   20459      1
            RANDOMPR_6         16902     0.29     17114   16902    16902    16902   16902      1
            RANDOMPR_7         20729     0.3      21114   21114    20729    20729   20729      1
            RANDOMPR_8         23974     0.39     26123   24144    23974    23974   23974      1
            RANDOMPR_9         19425     0.83     20353   20353    19425    19425   19425      1
            RANDOMPR_10        16850     1.26     20030   19601    16850    16850   16850      1
            RANDOMPR_11        27413     1.17     27496   27413    27413    27413   27413      1
            RANDOMPR_12        39240     0.46     39776   39241    39240    39240   39240      1
            RANDOMPR_13        19707     2.47     22869   20020    19707    19707   19707      1
            RANDOMPR_14        23391     2.46     26417   23665    23391    23391   23391      1
            RANDOMPR_15        23193     3.97     25037   24402    23193    23193   23193      1
            RANDOMPR_16        30960     2.99     31593   31019    30960    30960   30960      1
            RANDOMPR_17        27311     0.64     30071   28571    27311    27311   27311      1
            RANDOMPR_18        21209     1.36     23384   21784    21209    21209   21209      1
            RANDOMPR_19        13640     2.74     16053   15208    13640    13640   13640      1


Table 12: Computational results of the Three-Tree algorithm for Class 1 RPP random instances from
Hertz&al. (1998).
                                                                                                    46




                                Heur.                                          Opt.
                                 Sol.   Time in   Fred.    Sol.   Sol.   Sol.  Value
                                (HS)     Secs.    Sol.    Tree 1 Tree 2 Tree 3 (OV) OV/HS
             GRIDPROB_0          9       0.08       9        9        9       9        9       1
             GRIDPROB_1          9       0.14       9        9        9       9        9       1
             GRIDPROB_2          8       0.12       8        8        8       8        8       1
             GRIDPROB_3          8       0.13       8        8        8       8        8       1
             GRIDPROB_4          7       0.16       9        9        7       7        7       1
             GRIDPROB_5          5       0.12       5        5        5       5        5       1
             GRIDPROB_6          7       0.66       7        7        7       7        7       1
             GRIDPROB_7          6       0.13       8        8        6       6        6       1
             GRIDPROB_8          7       0.15       9        7        7       7        7       1
             GRIDPROB_9          11      0.48      11       11       11      11       11       1
             GRIDPROB_10         15      1.13      17       17       15      15       15       1
             GRIDPROB_11         15      1.35      17       15       15      15       15       1
             GRIDPROB_12         14      2.2       16       14       14      14       14       1
             GRIDPROB_13         17      1.86      17       17       17      17       17       1
             GRIDPROB_14         17      2.91      19       17       17      19       17       1
             GRIDPROB_15         13      1.08      13       13       13      13       13       1
             GRIDPROB_16         16      3.91      18       16       16      16       16       1
             GRIDPROB_17         14      1.02      16       16       14      14       14       1
             GRIDPROB_18         22      2.07      28       26       22      22       22       1
             GRIDPROB_19         25     19.41      29       25       25      25       23     0.92
             GRIDPROB_20         29      9.82      31       31       31      29       25    0.8621
             GRIDPROB_21         22     35.77      24       24       22      22       22       1
             GRIDPROB_22         19      3.31      27       23       19      19       19       1
             GRIDPROB_23         24      6.58      26       26       24      24       24       1
             GRIDPROB_24         22      5.81      22       22       22      22       22       1
             GRIDPROB_25         21      2.84      25       25       21      21       21       1
             GRIDPROB_26         16      3.32      20       20       16      16       16       1
             GRIDPROB_27         37     108.8      45       41       37      45       37       1
             GRIDPROB_28         35     40.74      45       43       35      35       35       1
             GRIDPROB_29         42     37.47      48       42       42      44       38    0.9048
             GRIDPROB_30         37     40.31      41       39       37      37       37       1
             GRIDPROB_31         37     186.21     47       45       37      37       37       1
             GRIDPROB_32         38     242.45     40       40       38      38       38       1
             GRIDPROB_33         35     10.92      37       37       35      35       35       1
             GRIDPROB_34         37     103.8      43       41       37      37       37       1
             GRIDPROB_35         33     40.44      33       33       33      33       33       1


Table 13: Computational results of the Three-Tree algorithm for Class 2 RPP random instances from
Hertz&al. (1998).
                                                                                                    47




                                Heur.
                                 Sol.   Time in   Fred.    Sol.   Sol.   Sol.  Opt.
                                (HS)     Secs.    Sol.    Tree 1 Tree 2 Tree 3 Value        OV/HS
                                                                               (OV)
            DEGREE4P_0          153      0.08      153     153    153    153    153            1
            DEGREE4P_1          451      0.24      451     451    451    451    451            1
            DEGREE4P_2          380      0.39      380     380    380    380    380            1
            DEGREE4P_3          411      0.19      411     411    411    411    411            1
            DEGREE4P_4          521      0.42      521     521    521    521    521            1
            DEGREE4P_5          473      0.85      496     496    473    473    473            1
            DEGREE4P_6          504      0.84      504     504    504    504    504            1
            DEGREE4P_7          457      0.33      490     490    457    457    457            1
            DEGREE4P_8          399      1.37      399     399    399    399    399            1
            DEGREE4P_9          666      1.67      724     674    666    666    666            1
            DEGREE4P_10         488      1.12      493     491    488    488    488            1
            DEGREE4P_11         459      4.1       536     536    459    459    459            1
            DEGREE4P_12         571      2.27      632     601    571    571    571            1
            DEGREE4P_13         347      2.36      369     347    347    347    347            1
            DEGREE4P_14         458      4.33      531     464    458    458    458            1
            DEGREE4P_15         492      3.49      528     492    492    492    492            1
            DEGREE4P_16         354       7        385     385    354    354    354            1
            DEGREE4P_17         448      4.38      515     448    448    448    448            1
            DEGREE4P_18         547      6.58      598     589    547    547    547            1
            DEGREE4P_19         644      9.77      724     701    644    644    644            1
            DEGREE4P_20         569      5.06      652     610    569    569    569            1
            DEGREE4P_21         451     13.59      540     519    451    451    451            1
            DEGREE4P_22         608     18.62      624     624    608    608    607         0.9984
            DEGREE4P_23         600     10.17      612     612    600    600    600            1
            DEGREE4P_24         465      7.29      495     486    465    465    465            1
            DEGREE4P_25         515     24.26      561     561    515    515    515            1
            DEGREE4P_26         573      6.56      573     573    573    573    573            1
            DEGREE4P_27         873     379.09     960     917    986    873    872         0.9989
            DEGREE4P_28         780     52.58      830     815    780    780    780            1
            DEGREE4P_29         882     175.81     979     960    882    896    846         0.9592
            DEGREE4P_30         722     236.5      769     769    722    722    722            1
            DEGREE4P_31         739     37.32      769     769    739    739    739            1
            DEGREE4P_32         659     272.51     709     697    659    659    659            1
            DEGREE4P_33         766     858.44     782     769    766    808    752         0.9817
            DEGREE4P_34         683      36.5      727     711    683    683    683            1
            DEGREE4P_35         638     102.86     664     656    638    638    638            1


Table 14: Computational results of the Three-Tree algorithm for Class 3 RPP random instances from
Hertz&al. (1998).
                                                                           48




           Heur.
            Sol.   Time in   Fred.    Sol.   Sol.   Sol.  Opt.
           (HS)     Secs.    Sol.    Tree 1 Tree 2 Tree 3 Value   OV/HS
                                                          (OV)
ALBA_3_1   3658    35.02     3889    3761 3734     3658   3542    0.9683
ALBA_3_2   3792    38.14     3934    3822 3828     3792 -3607     0.9512
ALBA_3_3   3664    13.13     3688    3672 3664     3666   3576     0.976
ALBA_3_4   3680    37.19     3920    3768 3680     3680 -3639     0.9889
ALBA_3_5   3313    33.63     3679    3595 3337     3313   3313       1
ALBA_5_1   4309    59.44     4613    4309 4525     4525   4289    0.9954
ALBA_5_2   3856    33.81     3856    3856 3876     3996   3820    0.9907
ALBA_5_3   3126    46.30     3294    3126 3130     3130   3126       1
ALBA_5_4   2987    13.34     3035    3035 2987     2987   2987       1
ALBA_5_5   3200    66.13     3558    3360 3200     3200   3196    0.9988
ALBA_7_1   3281    41.82     3281    3281 3281     3281   3281       1
ALBA_7_2   2588    11.04     2588    2588 2588     2588   2580    0.9969
ALBA_7_3   3239    46.72     3371    3259 3239     3239   3239       1
ALBA_7_4   3126    47.24     3126    3126 3126     3126   3126       1
ALBA_7_5   3433    36.53     3433    3433 3545     3441   3433       1
  GRP1     4214    176.99    4656    4520 4214     4214   4214       1
  GRP2     3884    81.90     4356    3884 4412     4010 -3872     0.9969
  GRP3     4290    90.46     4685    4493 4290     4290   4199    0.9788
  GRP4     2988    95.05     2988    2988 3696     3044   2717    0.9093
  GRP5     3284    38.06     3382    3358 3284     3284   3284       1
  GRP6     2702     5.90     2702    2702 2702     2702   2702       1
  GRP7     3682    41.64     3850    3850 3682     3682   3682       1
  GRP8     4316    89.61     4552    4392 4316     4492   4316       1
  GRP9     2292     5.92     2364    2364 2292     2292   2292       1
 GRP10     2808    357.31    2924    2924 2808     2924 -2668     0.9501
MADR_3_1   5110    385.21    6040    5280 5110     5215 -4906     0.9601
MADR_3_2   5610    296.55    6255    6015 5610     5775 -5439     0.9695
MADR_3_3   5500    524.22    6015    5610 5500     5670 -5338     0.9705
MADR_3_4   5570    704.21    6100    5830 5595     5570 -5395     0.9686
MADR_3_5   5050    349.19    6130    5665 5050     5280 -4928     0.9758
MADR_5_1   4150    82.93     4460    4330 4150     4150   4150       1
MADR_5_2   4930    255.58    5300    5070 4930     4975   4930       1
MADR_5_3   4245    116.18    4460    4300 4245     4370   4170    0.9823
MADR_5_4   4715    225.36    5260    4965 4725     4715   4640    0.9841
MADR_5_5   4890    698.76    5175    4890 4955     4905   4760    0.9734
MADR_7_1   4655    51.24     4755    4655 4655     4655   4655       1
MADR_7_2   4615    43.51     4615    4615 4615     4615   4615       1
MADR_7_3   4505    20.55     4505    4505 4505     4505   4505       1
MADR_7_4   3815    18.02     3815    3815 3815     3815   3815       1
MADR_7_5   4525    21.32     4525    4525 4525     4525   4525       1
                                                                                         49



Table 15: Computational results of the Three-Tree algorithm for the “genuine” GRP instances
                                 from Corberán&al. (1998)

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:18
posted:5/17/2011
language:English
pages:49