An exact approach for the vehicle routing problem with two-dimensional loading constraints

We consider a special case of the symmetric capacitated vehicle routing problem, in which a fleet of K identical vehicles must serve n customers, each with a given demand consisting in a set of rectangular two-dimensional weighted items. The vehicles have a two-dimensional loading surface and a maximum weight capacity. The aim is to find a partition of the customers into routes of minimum total cost and such that, for each vehicle, the weight capacity is taken into account and a feasible two-dimensional allocation of the items into the loading surface exists. The problem has several practical applications in freight transportation and it is NP-Hard in the strong sense. We propose an exact approach, based on a branchand-cut algorithm, for the minimization of the routing cost, that iteratively calls a branch-and-bound algorithm for checking the feasibility of the loadings. Heuristics

are also used in order to improve the overall performance of the algorithm.The effectiveness of the approach is shown by means of computational results.

Introduction
Given a central depot, the Vehicle Routing Problem (VRP) calls for the determination of the optimal set of routes to be performed by a fleet of vehicles, in order to satisfy the demand of a given set of customers.Several important variants of this basic problem were extensively studied in the literature (see, e.g., Toth and Vigo (2002b) for a recent review).
In particular, the symmetrical Capacitated VRP (CVRP) is the well-known variant of the VRP where all vehicles are identical and have a maximum loading capacity, and all the arcs in the graph representing the underlying road network can be travelled along both directions, producing the same cost.
In the CVRP literature, the demand of each customer is generally expressed by a positive integer that represents the total weight or volume of the demanded items.In this case, checking the feasibility of a solution simply requires one to ensure that the sum of the demands of the customers assigned to each vehicle does not exceed its total loading capacity.However, in many practical freight distribution applications, the loading of the items into the vehicles can represent a difficult problem, especially for large-size items.In this case, the loading pattern of the items on each vehicle must be found in order to achieve feasible solutions to the routing problem.These loading issues may have a great impact on the sequencing of the customers along the routes, and common examples of such situations may be found in the distribution of goods such as furniture, mechanical components and household appliances.
Many of these applications incorporate relevant additional features that influence the actual loading problem to be solved.For example, the items are often transported on top of rectangular bases, e.g., large pallets of suitable size, and due to their fragility or shape, they The 2L-CVRP combines the classical and extensively studied CVRP, with a loading problem that is closely related to the well-known Two-Dimensional Bin Packing Problem (2BPP).The 2BPP calls for the determination of a packing pattern of a given set of rectangular items into the minimum number of identical rectangular bins.
It is clear that the 2L-CVRP is strongly N P-Hard since it generalizes the CVRP.Moreover, the two problems which are combined to obtain the 2L-CVRP are extremely difficult to solve.State-of-the-art exact approaches for the CVRP have solved instances with up to 135 customers, but within a reasonable computing time (i.e., some hours on a common PC) they can generally solve instances with up to 100 customers (see, e.g., Toth and Vigo (2002b), and Fukasawa et al. ( 2004)).Also the 2BPP is very difficult to solve in practice.Exact algorithms and lower bounds were recently proposed by Martello and Vigo (1998), Fekete and Schepers (2001, 2004a, 2004b), Boschetti andMingozzi (2003a, 2003b) and Pisinger and Sigurd (2003).Exact approaches for the 2BPP are generally able to solve instances with up to 100 items, but fail in many cases for smaller instances.In the literature, the problems derived from the 2BPP with some additional side constraints are generally included in the category of Container Loading Problems (2CLP).For the 2CLP, heuristic approaches have been proposed by Pisinger (1998Pisinger ( , 2002) ) and Bortfeld and Gehring (2000), an analytical model was proposed by Chen et al. (1995) and an LP-based bound was presented by Scheithauer (1992Scheithauer ( , 1999)).Finally, packing requirements similar to the sequential loading we consider are studied in Pisinger et al. (2005).
The 2L-CVRP has not been previously studied in the literature.The only closelyrelated reference we are aware of is on a VRP with three-dimensional loading constraint introduced by Türkay (2003), who proposed a general integer programming model derived from the Container Loading model proposed by Chen et al. (1995).The resulting approach was used to solve an instance involving 5 items and 5 customers.In addition, pickup and delivery problems with rear-loaded vehicles were also studied in the literature, see, e.g., Xu et al. (2003).This paper presents an exact algorithm for the solution of the 2L-CVRP based on a branch-and-cut approach, that proved to be a successful technique for the solution of related problems such as the CVRP (see, e.g., Naddef and Rinaldi (2002)).Within the algorithm we used both basic classes of valid inequalities derived for the CVRP, as well as specific valid inequalities associated with infeasible loading sequences.To this end, the feasibility of a given loading pattern is determined through lower bounds, effective heuristics and a specialized branch-and-bound algorithm.The overall algorithm was extensively tested on benchmark instances derived from the CVRP test problems and showed a satisfactory behavior, being able to optimally solve instances with up to 35 customers and more than 100 items.
The paper is organized as follows.Section 2 describes in detail the new problem and introduces the necessary notation.Section 3 presents an exact approach derived from the standard branch-and-cut algorithm for the CVRP, strengthened by new inequalities that take into account the vehicle loading component of the 2L-CVRP.The separation of these loading constraints is addressed in Section 4 through a specific branch-and-bound procedure.Section 5 examines the computational results and Section 6 draws some conclusions.

Problem Description
The 2L-CVRP may be defined as follows.We are given a complete undirected graph G = (V, E), in which V defines the set of n + 1 vertices corresponding to the depot (vertex 0) and to the customers (vertices 1, . . ., n).For each edge e ∈ E the associated travelling cost, c e , is defined.In the following, a given edge e can be also represented by its endpoint vertices {ij}.
A set of K identical vehicles is available at the depot.Each vehicle has a weight capacity D and a rectangular loading surface, that is accessible from a single side for loading and unloading operations, whose width and height are equal to W and H, respectively.We also denote by A = W H the total area of the loading surface.
Each customer i (i = 1, . . ., n) is associated with a set of m i rectangular items, whose total weight is equal to d i , and each having specific width and height equal to w i and h i , ( = 1, . . ., m i ), respectively.Each item will be denoted by a pair of indices (i, ).In addition, we denote by a i = m i =1 w i h i the total area of the items of customer i.Finally, let M = n i=1 m i denote the total number of items.We assume that all the above input data are positive integers.
The loading of the items on a vehicle is subject to the following specific constraints: Item clustering: All the items of a given customer must be loaded on the same vehicle.Therefore, for each customer i, we assume that d i ≤ D and there exists a feasible two-dimensional loading of the m i items into a single vehicle surface (i = 1, . . ., n).
Item orientation: Items have a fixed orientation (i.e., they may not be rotated) and must be loaded with their sides parallel to the sides of the loading surface (i.e., a so-called orthogonal loading is required).
Sequential loading: Unloading operations at the customers' site are performed through a single side of the vehicle and may not result in a load rearrangement on the vehicle or in lateral shifts of the item to be unloaded.Therefore, when unloading the items of a customer, no item belonging to customers served later along the route may either be moved or block the removal of the items of the current customer.In other words, no lateral movement of the items is allowed inside the vehicle when serving a customer.
We now give a more formal definition of a feasible route in our routing problem.A feasible route is associated with a subset S of customers and with a sorting denoted by a bijection σ : S → {1, . . ., |S|}, where σ(i) is the order in which customer i ∈ S is visited along the route.A first condition that a route (S, σ) must satisfy is relative to the item weights, and is the classical capacity restriction of the CVRP: Condition 1: The weight capacity of the vehicle may not be violated, i.e., The remaining conditions refer to the loading pattern.It is convenient to map the loading surface onto the positive quadrant of a Cartesian coordinate system, whose origin (0, 0) corresponds to the bottom-left corner of the loading surface in the vehicle, and where the x-axis and y-axis correspond to its bottom and left sides, respectively.The position of an item (i, ) within the vehicle can be defined by two variables x i and y i , representing the coordinates of its bottom-left corner in the loading surface.The loading/unloading side of the vehicle is placed at height H.Then, the values for these variables must satisfy the following conditions: Condition 2: The items must be completely contained within the loading surface, i.e., 0 ≤ x i ≤ W − w i and 0 ≤ y i ≤ H − h i for all i ∈ S and ∈ {1, . . ., m i }.
Condition 3: No two items can overlap, i.e., x i + w i ≤ x j or x j + w j ≤ x i or y i + h i ≤ y j or y j + h j ≤ y i for all i, j ∈ S, ∈ {1, . . ., m i }, ∈ {1, . . ., m j }, and (i, ) = (j, ).
Condition 4: (Sequential loading) When unloading an item, say (i, ), no item of customers served later along the route may lay, even partially, in the rectangular area from item (i, ) and the loading/unloading side of the truck, i.e., y i ≥ y j + h j or x i + w i ≤ x j or x j + w j ≤ x i for all i, j ∈ S : σ(i) < σ(j), ∈ {1, . . ., m i } and ∈ {1, . . ., m j }.
The cost of a feasible route is the sum of the travelling costs of the edges required to visit the customers in the specified sequence, starting and ending at the depot.Then, the 2L-CVRP consists of finding K feasible routes with minimum total cost, and such that each customer is exactly in one of them.An important observation when comparing the 2L-CVRP and the classical CVRP, is that the sequence σ is relevant to the feasibility of a route visiting customers in S.
Figure 1 also shows that route (S, σ 2R ) in the opposite direction of σ 2 , defined by , is also a feasible route for the 2L-CVRP.This is a general result, because whenever (S, σ) is a feasible route, then also (S, σ R ), where The loading pattern can be obtained by applying a symmetry operation with respect to line y = H/2, and consequently changing Note that, as a consequence, the opposite route of an infeasible route is also infeasible.
In the following sections we describe the overall approach used to solve the 2L-CVRP.

A Branch-and-Cut Approach
This section proposes an integer linear programming model for the 2L-CVRP using large families of linear inequalities.The model is later used to solve the problem through a branch-and-cut algorithm.This section also presents the separation procedures used to find violated inequalities of the families describing the model, and a primal heuristic to speed up the solution of the algorithm.

Problem Formulation
To model the 2L-CVRP we adapted the classical two-index vehicle flow model for the CVRP (see, e.g., Toth and Vigo (2002a)).It uses a binary variable z e for each e ∈ E which takes value 1 if and only if a vehicle travels along edge e in a feasible route.The resulting formulation is: e∈δ( 0) e∈δ(S) for all e ∈ δ(0) Constraints ( 2) and (3) impose degree requirements at the customer vertices, and at the depot, respectively.Constraints (4), known as the capacity-cut constraints, impose both solution connectivity and feasibility with respect to Conditions 1-3 of Section 2. In these constraints, r(S) is the minimum number of vehicles that are necessary to serve the customers in set S, and not considering the actual sequence in which they are visited (i.e., by disregarding Condition 4 introduced in Section 2).Constraints ( 5), known as infeasiblepath constraints, consider the loading sequence requirements expressed by Condition 4 by eliminating non-feasible sequences σ associated with a customer set S. Finally, constraints ( 6) and (7) impose that the variables associated with the edges connecting two customers are binary, and those connecting the customers to the depot may also take value two (thus representing a single-customer route).
It is well-known that for the classical CVRP the computation of r(S) is difficult, as it amounts to solving a one-dimensional Bin Packing Problem (1BPP) associated with customer set S and with respect to item weights and vehicle capacity.In our case, this is even more complex since we must also take into account the 2BPP associated with the loading of the items into the vehicles, with the additional side constraint that all the items of any given customer must be loaded into the same bin.Therefore, as it is usually done in the literature, we replace r(S) by a lower bound on its value given by a simple relaxation.
In particular, we used where the first term is the well-known 1BPP continuous lower bound associated with the customer weights, and the second term is the 2BPP continuous lower bound computed with respect to the total item area of the customers in S. Bound r (S) may be further where also other lifted inequalities can be found.Some of these inequalities were later considered in Bard et al. (2002) to solve the asymmetric version of the CVRP with Time Windows.
Formulation ( 1)-( 7) has the disadvantage of including the large families of constraints ( 4) and ( 5).However, by applying a branch-and-cut approach, we actually do not have to include all of them explicitly in the model, but just to define suitable separation procedures.
Given a solution z * of a relaxed model of ( 1)-( 7), the separation problem consists of either proving that all constraints in a given family are satisfied by z * , or finding a violated one.
In the next section we introduce simple separation procedures for constraints (4) and (5).

Separation Procedures
Due to the definition of r(S), constraints (4) induce a separation problem which is N P-Hard (see Naddef and Rinaldi (2002)).Therefore, it is unlikely that we can design a polynomial-time exact algorithm for determining a constraint (4) violated by z * when it exists.Nevertheless, as it is done for the CVRP, it is possible to propose good heuristic procedures to possibly find such a violated constraint.To this end, we adapted some simple heuristic procedures used for the same constraints in the CVRP (see, e.g., Naddef (2002)), so as to take into account also the areas of the items.In particular, we used:  Let us now address the separation problem associated with infeasible-path constraints (5).Some heuristic separation approaches for inequalities similar to (5) were presented in the literature (see, e.g., Ascheuer et al. (2001) and Bard et al. (2002)).However, for the 2L-CVRP checking the feasibility of a given path is considerably more time consuming and this is the reason why in our approach we separate these constraints only when Procedures 1-3 do not return a violated constraint (4), and when the current solution z * is integer.It should be observed that in this case z * defines a solution of 2L-CVRP made up by exactly K routes so that the subsets of customers associated with each different route, as well as the visit order of the customers along the routes, are uniquely determined.
More precisely, we have the following: Procedure 4: For each route (S, σ) in the current solution, check its feasibility with respect to the loading Conditions 2-4 of Section 3.1, by using the exact algorithm Check-2L to be described in Section 4. If route (S, σ) is not feasible, then add the associated constraint (5) to the current model.Otherwise, if all routes are feasible, the overall incumbent solution is possibly updated.
We note that, since the feasibility check of a route is actually an N P-Complete problem, it can happen that procedure Check-2L must be stopped whenever a prescribed time limit is exceeded without proving either the feasibility or the infeasibility of the given route.

Strengthening the LP-relaxation
The extensive literature on the CVRP shows different inequalities that can be added to the linear relaxation of model ( 1)-( 4), see, e.g., Naddef and Rinaldi (2002).An example of these inequalities is represented by the following multistar inequalities: for all S ⊆ V \{0}.We also note that one could also consider another class of multistar inequalities (9) where item and vehicle loading areas are used, as done with the capacity-cut constraints (see equation ( 8)).

Branching scheme
Whenever the LP-relaxation, strengthened with the additional cuts, does not produce a 2L-CVRP solution, then a branching phase is applied.In our implementation, we used the branch-and-bound framework provided by CPLEX 8.1 solver.We conducted an extensive testing on some instances from our benchmark set in order to define the most effective branching scheme and search strategy.We also compared the different search strategies provided by CPLEX and the most effective one was a combination of the "best promising node" and depth-first search (which can be obtained by setting to 0.5 the parameter CPX PARAM BTTOOL).
At each node we use the separation procedures described in Section 3.2.In addition, the heuristic algorithm to be described in the next section is applied to the final LP relaxation, both to possibly update the incumbent solution and to detect further violated inequalities of type (5) to be added to the current model.
As previously mentioned, separation procedure 4 requires checking the feasibility of a given route through algorithm Check-2L.Since this feasibility check may be very time consuming, we introduced stopping conditions for Check-2L based on maximum number of backtrackings and time limit.Whenever one of these conditions is achieved we are clearly neither able to find a feasible loading of the vehicle, nor to prove the infeasibility of the route.In this case we heuristically consider the route infeasible and add the corresponding (possibly not valid) cut to the current model.We should note that this implies that the final 2L-CVRP solution is not guaranteed to be optimal.However, our extensive computational experience has shown that this is a relatively rare event.

Heuristic Algorithms
The performance of the overall approach is enhanced by using specific heuristic algorithms for the 2L-CVRP to both derive an initial feasible solution at the root node and to possibly update the incumbent solution at other decision nodes.
A heuristic for the 2L-CVRP should combine the routing component with the twodimensional loading one.To this end, a set of routes is determined by using a parametric sequential insertion heuristic that takes into account both classical routing cost minimization, as well as two-dimensional packing insertion criteria.The obtained routes are improved by means of a two-opt exchange procedure and then checked for feasibility by using procedure Check-2L to be defined in Section 4.
The insertion algorithm operates as follows.It constructs one (possibly feasible) route Γ i , the cost of the best insertion of customer i in the route (S, σ).
The modified insertion cost of customer i in route (S, σ) is then: where α, β, γ are suitably defined non-negative parameters such that α + β + γ = 1.In addition, Γ i = ∞ whenever either a i > A res or d i > D res .It should be observed that parameters α, β and γ allow the combination of classical routing and packing insertion criteria.For example, when (β = γ = 0) we have the cheapest insertion rule used for the CVRP (see, e.g., Mole and Jameson (1976)).On the other hand, when α = γ = 0 (or alternatively α = β = 0) the insertion criterion turns out to be the well-known first fit rule used in the bin packing context (see, e.g., Johnson (1973)).
As soon as the current vehicle may not accommodate further customers and the total number of used routes is smaller than K, a new route is initialized and the insertion process is iterated.If all customers were inserted in the K routes, then a first-improvement descent procedure based on a two-opt neighborhood is applied to possibly improve the overall solution cost.
This constructive procedure is repeated ten times with different values of parameters α, β and γ, and the best solution is considered (see Iori (2004) for details).If the resulting solution value is smaller than the actual best known feasible 2L-CVRP solution, then the actual feasibility with respect to the loading of each route is checked through procedure Check-2L, to be described in Section 4. The procedure is called with a limit on the CPU time and on the maximum number of backtrackings.If all routes are feasible, then the current best known 2L-CVRP solution is updated.Otherwise, for each route that is proved to be infeasible the corresponding constraint is generated and added to the model.
The above heuristic procedure is executed at the beginning of the branch-and-cut algorithm to possibly produce a first feasible 2L-CVRP solution.In order to exploit the information of the current LP-relaxation at each branch-decision node, this heuristic scheme is also executed with modified edge costs defined as where, for each edge e ∈ E, c e is the original cost and z * e is the value of the associated variable in the current LP solution.

A Branch-and-Bound Algorithm for the Loading-Check Problem
The overall solution approach for the 2L-CVRP outlined in the previous section strongly relies on a procedure to check the existence of a feasible loading pattern for a given route (S, σ), according to Conditions 1-4 of Section 2. This problem hereafter is referred to as 2L.It is easy to see that 2L is N P-Complete in the strong sense, since it generalizes other two-dimensional single-bin filling problems, such as the one described in Martello et al.
In this section we describe an algorithm, called Check-2L, to exactly solve problem 2L.
The algorithm is based on a branch-and-bound approach, and extends the one proposed by Martello et al. (2000) for a two-dimensional single-bin filling problem arising within the solution of the three-dimensional Bin Packing Problem (3BPP).
At the root node of the branch-and-bound search tree we compute lower bounds to possibly avoid entering the actual enumeration scheme.To this end, we relax the sequential loading requirements and use the lower bounds proposed by Martello and Vigo (1998) for the 2BPP.If the largest lower bound value is greater than one, then clearly the 2L instance is infeasible.Otherwise, the items are sorted in reversed customer loading sequence (i.e., the first customer to be visited is the last one to be loaded on the vehicle), and by nonincreasing width within each customer (breaking ties by non-increasing height).
We then use a simple heuristic procedure, derived from the classical bottom-left approach (see, e.g., Berkey and Wang (1987)), to possibly detect a feasible single-bin loading pattern.The heuristic places one item at a time (in the given order) in the lowest feasible position in the loading surface and left-justified, checking that Conditions 2-4 are not violated.
Whenever the lower and upper bounds did not prove the feasibility or infeasibility of the route (S, σ), an implicit enumeration scheme is used.The scheme starts with an empty solution and generates one descendant node for each item, in the given order, by placing it in the bottom-left position (i.e., at coordinates (0, 0)) of the loading surface.
At each subsequent level of the search tree, a new item is placed in a feasible position of the loading surface.Given a partial solution associated with a node of the search tree, where some items have been placed, descendant nodes are generated, one for each nonplaced item and for each feasible placement position.Scheithauer (1997) showed that the set of feasible placement positions for the 2BPP can be limited to the finite set of the contour points of the contour associated with the already placed items (similar results were described by Martello et al. (2000) for the 3BPP where such points were called corner points).In the 2L case we have to consider additional placement positions as a consequence of the customer sequencing constraints, that prevent the placement of an item at positions that would block the removal of other items belonging to customers visited earlier in the route.
More precisely, given a partial loading associated with a route (S, σ) and the current item to be placed, say (i, ), two different cases may happen.The simplest one arises when item (i, ) does not block any of the already placed items (i , ), i.e., when σ(i) ≤ σ(i ).
Then, the only placement positions to be considered for (i, ) are the contour points defined by Scheithauer (1997).Such situation is illustrated through a simple example depicted in circles.We note that, as explained in Scheithauer (1997), we can consider the area above item (1, 1) and below the contour as "trapped" and not available for placement of items in the descendant nodes, thus allowing for a reduction of the enumeration tree size.If the next item to be placed belongs to customer 1 it will not block the previously placed items, hence its only placement positions are the contour points (0,20) and (7,16).
Available for customer 1

Available for customers 1and 2
Available for all customers ( The second case arises when the current item (i, ) may block already placed items.(In the example of Figure 2 this happens when the next item to be placed belongs to customers 2 or 3.) For the sake of simplicity, let us consider that there is a single already placed item, say (i , ), that may be blocked by (i, ).This incompatibility removes the area above item (i , ) from the area where item (i, ) may be placed.Intuitively this splits the area above the contour in at most two new subareas where the placement positions for item (i, ) have to be found.Since in each such subarea blocking incompatibilities are no longer present, the placement positions for (i, ) are the union of those determined within each subarea.
It is easy to observe that each item (i , ) that may be blocked by (i, ) can create at most one new placement position with respect to the original set of contour points determined when blocking incompatibilities are ignored.In the example of Figure 2, if the item to be placed belongs to customer 2, the area above item (1,1) is not available, and the resulting additional placement position is (14,16), indicated by a filled circle.
When more than one, say p, items may be blocked by the current item (i, ), we observe that area above the contour is split in at most p + 1 different subareas.Thus, in practice, the overall set of placement positions for (i, may include at most p additional points with respect to the set of the original contour points. Whenever an item is placed, we may perform feasibility tests and compute lower bounds to possibly fathom the current node of the enumeration tree.Martello et al. (2000) used for the single-bin 2BPP and 3BPP, a simple bound that estimates the total area, T , that can be placed given a partial allocation, as the sum of the areas of the already placed items, plus the total available area above the contour.If T is not greater than the largest total placed area T * found so far, then the current node can be clearly fathomed since it may not lead to an improved solution.
In our case, we may define additional simple feasibility tests by again considering the subdivision of the area above the contour imposed by the sequencing constraints.In particular, for each customer we may define the subareas that may be used to place his items.Then, we may fathom the current node as soon as the available area for a given customer is smaller than that of his unplaced items.Figure 2 illustrates this by showing the three subareas in which the area above the contour is divided.In addition, we may fathom the current node if, for a given customer, the total width of adjacent subareas that may accommodate his items is smaller than the width of his widest unplaced item, or when the maximum height of the available subareas is smaller than the height of his tallest unplaced item.
As previously mentioned, procedure Check-2L may consume a large portion of the or Horizontal, is selected with equal probability, and the corresponding item sizes are randomly generated in the intervals given in Table 1.
Table 1: Classes used for the generation of the items.It should be observed that in these instances there is no correlation between the weight of the items and their overall area.In preliminary experiments, we also extensively generated correlated instances, and they resulted easier to solver than the uncorrelated ones (see Iori (2004) for more details).
For each instance, the number K of available vehicles is determined as follows.For instances of Class 1, K is set equal to the corresponding value in the original CVRP instance, denoted as K CVRP .For the other classes, we heuristically solve a 2BPP associated with the items, by using an adaptation to 2BPP of the heuristic described in Martello et al. (2000) for the 3BPP.Then K is set to the maximum value between the number of bins in this heuristic solution and K CVRP .It should be noted that, since in the heuristic 2BPP approach clustering and sequential loading constraints are not explicitly taken into account, the resulting K may be smaller that the actual minimum number of vehicles needed to load all the items, thus leading to an infeasible 2L-CVRP instance.However, this situation never occurred in our experiments: the exact algorithm was always able to find a feasible solution using this heuristic K value.
We finally note that, as frequently done in the routing context, we did not allow singlecustomer routes.
We considered 12 CVRP instances and, for each of them, we generated one instance for each class, obtaining in total 60 instances, with up to 35 customers and 114 items.The original CVRP instances and the complete set of 2L-CVRP instances can be downloaded from http://www.or.deis.unibo.it/research.html.
We imposed a CPU time limit of 86400 seconds (i.e., one day) to the overall algorithm.
The branch-and-bound algorithm of Section 4 was allowed a maximum time of 7200 seconds (i.e., 2 hours) for each execution of Check-2L requested by the Separation Procedure 4 of Section 3.2, and a maximum time of 100 seconds as well as a maximum number of 10000 backtrackings for each execution requested by the heuristic algorithm of Section 3.5.
These values were determined during a preliminary tuning of the algorithm, performed by considering a small subset of instances, and represent a good compromise between computing time and overall performance.
The results of our computational experience are summarized in Tables 2 and 3 We note that a solution is proved to be optimal if and only if it achieves F ails = 0 and % gap = 0.These optimal values are depicted in bold characters.
By observing Tables 2 and 3, we may see that the proposed algorithm was able to solve all instances with up to 25 customers within moderate computing time (always smaller than one hour), whereas a few larger instances were not solved within the overall time limit.
The size of the solved instances is consistent with the results reported in the literature for the two separate problems that are combined into the 2L-CVRP.Indeed, a basic branchand-cut approach for the CVRP using just simple separation procedures for constraints (4) may hardly solve instances with more than 30 customers, whereas state-of-the-art branchand-bound algorithms for 2BPP (see, e.g., Martello and Vigo (1998)) may solve loading instances similar to those generated in our work with at most 80-100 items.
The effect of the loading component of the 2L-CVRP is witnessed by the fact that both K and the optimal solution value are in general larger than those of the original CVRP instance.For classes 2, 3, 4 and 5, the average increase in the solution value, with respect to the CVRP solution, is, respectively, 8, 8%, 9, 3%, 5, 9% and 5, 60% (computed by considering only the proved optimal values).The few exceptions to this increase in the routing cost are represented by instances of Class 5, in which the item sizes are relatively small.
Procedure Check-2L proved to be particularly efficient for the resolution of the 2L.For the complete set of instances, out of 9869 times in which it was called by the Separation Procedure 4, Check-2L failed only 32 times to prove the feasibility or infeasibility of the loading.These exceptions arise for one instance of Class 4 and two instances of Class 5, and this is explained by the fact that these classes are characterized by a large number of items to be loaded into each vehicle.This is a typical feature of very difficult 2BPPs.As a consequence, for each CVRP instance, T load augments from Class 2 to Class 5, and in some cases can absorb a very large part of the computing time.We also note that the final solutions of instances E030 − 03g Class 4 and Class 5 were not proved to be optimal, due to the failures of Check-2L that may result in the addition of possibly not valid cuts (see Section 3.4).The execution of the algorithm for instance E033 − 03n Class 2 was halted before the time limit of one day because it had reached a maximum memory limit.
When addressing larger CVRP instances, T rout increases consistently.This is however not surprising, since it is well known that the separation of constraints (4) does not suffice for the quick solution of CVRPs of these sizes through branch-and-cut.All the instances of Class 1 are solved to optimality.Among the other classes (where the routing does not absorb the entire computing time granted to the algorithm), in three cases the branch-andcut approach does not manage to explore the whole tree, and gives back a value of % gap that can be very high.The number of cuts added during the execution of the algorithm may be quite large and increases with the size of the instance.

Conclusions
In this paper we examined the problem of finding the optimal routes for K vehicles used to serve the demand of n customers, consisting of a set of two-dimensional rectangular items with given sizes and weight.Each vehicle has a weight capacity limit and a rectangular loading surface.The problem, denoted as 2L-CVRP, combines the well-known Capacitated Vehicle Routing Problem and the two-dimensional Bin Packing Problem, and leads to a very complicated overall combinatorial problem.
We presented an integer linear programming model for the 2L-CVRP, containing two families of constraints, used to impose the weight capacity-cut constraints and to forbid infeasible loading patterns.Since both families involve an exponentially-growing number of constraints, we adopted a branch-and-cut approach for the exact solution of the model, using heuristic separation procedures to possibly detect violated constraints.
The proposed approach was successfully tested on instances derived from classical CVRP ones, involving up to 35 customers and more than 100 items.Within 24 hours of computing time, the proposed algorithm was able to solve all the instances of the test bed except five cases.Moreover, all the instances with at most 25 customers were solved in less than one hour of computing time.

Figure 1
Figure 1 illustrates two different sequences σ 1 and σ 2 associated with the same customer subset S = {1, 2, 3}.Each customer has just one item.The sizes of the items and of the loading surface are proportional to those depicted in the figure.Route (S, σ 1 ) is defined by strengthened by considering better 2BPP lower bounds, such as those presented in Martello and Vigo (1998), Fekete and Schepers (2001, 2004b), and Boschetti and Mingozzi (2003a).The asymmetric version of the infeasible-path constraints (5) was introduced to formulate the Travelling Salesman Problem with Time Windows in Auscheuer et al. (2000),

Procedure 1 :
Let us consider the support graph G * = (V, E * ) of z * defined by E * := {e ∈ E : z * e > 0} and by a capacity z * e associated with edge e.For each customer i, find the min-cut δ(S * ) separating 0 from i, and such that i ∈ S * .Then check the constraint (4) defined by S := S * for potential violation with respect to the relaxed right-hand side r (S).

Procedure 2 :Procedure 3 :
Let us consider a dummy vertex n + 1 and define a graph G = (V ∪ {n + 1}, E ) where E contains all the edges in E * with the same capacities as in Procedure 1, plus a new edge connecting i and n + 1 with capacity 2d i /D.Find the min-cut δ(S ) separating 0 from n + 1 and such that n + 1 ∈ S , and check constraint (4) defined for S := S \ {n + 1}.The same as Procedure 2 but with capacities 2a i /A on the dummy edges.
These inequalities were introduced by Araque et al. (1990) for the CVRP with unit demands.Later, Fisher (1995) and Gouveia (1995) generalized them to the CVRP with general demands, and Blasum and Hochstättler (2000) and Letchford et al. (2002) provided polynomial separation procedures based on solving max-flow problems.
at a time.The route is initialized by connecting the depot to the most distant unrouted customer.The next vertex to be inserted is selected as the one minimizing a modified insertion cost Γ i , that takes into account the simple routing insertion cost, the residual area in the vehicle and the residual weight capacity.More precisely, given a customer i and the current route (S, σ), let us define A res = (A − i∈S a i ), the residual loading area in the vehicle; D res = (D − i∈S d i ), the residual weight capacity in the vehicle;

Figure 2 ,
Figure 2, in which we consider a vehicle loading surface with W = 20 and H = 30.The figure gives a partial loading associated with a route (S, σ), with S = {1, 2, 3} and σ(1) = 1, σ(2) = 2 and σ(3) = 3, where four items of these customers have already been placed.The current contour is indicated in the figure by a thick dashed line, and the set of contour points is made up by the two positions (0, 20) and (7, 16), indicated by empty
. For each instance, Name and Class give the name of the original CVRP instance and the class used for the creation of the items, respectively.Then, n represents the number of customers, M the total number of items and K the number of available vehicles.The performance of the algorithm in the solution of each instance is summarized in three groups of columns denoted as Loading, Routing, and Overall.For what concerns the loading group, P ool reports the size of the pool of the feasible and infeasible loading constraints kept in memory, and N BB gives the total number of times algorithm Check-2L was called by the Separation Procedure 4 of Section 3.2.F ails gives the number of calls in which Check-2L was not able either to find a feasible loading for the subproblem, or to prove its infeasibility.Finally, T load represents the total CPU time in seconds used by the loading-related procedures.It is worth noting that the pool is filled with N BB (feasible or infeasible) entries by the Separation Procedure 4, and P ool − N BB entries by the heuristic approach of Section 3.5.In the routing group, Cuts gives the number of cuts obtained through Separation Procedures 1-4 and added to the reduced model (not including default cuts added by CPLEX), % gap reports the percentage gap between the value z of the best feasible solution found and the final lower bound LB of the root node (computed as % gap = 100(z − LB)/LB), and T rout gives the total time spent by the routing-related procedures.Finally, in the overall group, z gives the value of the best feasible solution found, T z the time required to obtain such a solution (i.e., the time in which the last update of the incumbent solution was made), and T tot reports the computing time used by the overall algorithm (i.e., T tot = T load + T rout ).All the times are expressed in seconds on a Pentium IV 3 Ghz.

Table 2 :
Overall performance of the algorithm.