Embed Size (px)
Citation preview
Decomposition Branchingfor Mixed Integer Programming
Baris Yildiz1, Natashia Boland2, and Martin Savelsbergh2
1Department of Industrial Engineering, Koc University, Istanbul, Turkey2H. Milton Stewart School of Industrial & Systems Engineering, Georgia
Institute of Technology, Atlanta, USA
Abstract
We introduce a novel and powerful approach for solving certain classes of mixedinteger programs (MIPs): decomposition branching. Two seminal and widely used tech-niques for solving MIPs, branch-and-bound and decomposition, form its foundation.Computational experiments with instances of a weighted set covering problem anda regionalized p-median facility location problem with assignment range constraintsdemonstrate its efficacy: it explores far fewer nodes and can be orders of magnitudefaster than a commercial solver.
1 Introduction
Applications of mixed integer programming can be found in many industries, such as trans-portation, healthcare, energy, and finance, and their economic impact is significant. This isdue, in part, to the availability of effective and robust commercial solvers: FICO Xpress Op-timization (www.fico.com), IBM ILOG CPLEX Optimization Studio (www.ibm.com), andGurobi Optimizer (www.gurobi.com). What were initially highly specialized optimizationcodes, sold by small companies, have migrated to full optimization suites offered by largesoftware and solution vendors.
It is well-known that mixed integer programs (MIPs) can be very difficult to solve. Theirchallenge continues to stimulate research in the design and implementation of efficient andeffective techniques that can better solve them. For an overview of integer programming andits history, we refer the interested reader to Nemhauser and Wolsey (1988); Schrijver (1998);Wolsey (1998); Junger et al. (2010); Bixby (2012); Conforti et al. (2014).
Two seminal and widely used techniques for solving MIPs, branch-and-bound and de-composition, form the foundation for the research presented in this paper, where we combinethese techniques in an innovative way to develop a novel approach for solving MIPs: decom-position branching.
1
Branch-and-bound (Land and Doig, 1960) has become the standard paradigm for solvingMIPs. Consequently, designing effective branching schemes has attracted substantial atten-tion over the years. Major developments in this area include the introduction of pseudo-costbranching (Benichou et al., 1971), strong branching (Applegate et al., 1995), and reliabilitybranching (Achterberg et al., 2005). Surveys on branching schemes include Linderoth andSavelsbergh (1999) and Morrison et al. (2016). Recent research employs machine learningtechniques to discover the best branching scheme for solving a particular instance as thesearch progresses (Le Bodic and Nemhauser, 2015; Khalil et al., 2016; Lodi and Zarpellon,2017; Dilkina et al., 2017). However, all this work concentrates on branching schemes basedon single-variable dichotomy, and focuses primarily on the variable selection step, i.e., thechoice of the variable to branch on. In this paper, we develop a new branching scheme thatis quite different and not based on single-variable dichotomy. The scheme’s branching rulesdivide the search space by exploiting decomposable structure in the problem.
It is well-known that real-life instances often exhibit a decomposable or nearly decom-posable structure, where an instance has a nearly decomposable structure if the coefficientmatrix has a bordered block-diagonal form: the nonzeroes in the matrix comprise a set ofdisjoint blocks with either a small set of linking constraints or linking variables. In theirsurvey on progress in presolving for MIPs, Gamrath et al. (2015) observe that many “real-world supply chain management instances ... contain independent subproblems”, meaningthat they have a decomposable form with no linking variables nor linking constraints. Sur-prisingly, 34 out of 41 of the supply chain management instances used in their computationalstudy had independent subproblems, and many had a large number of them. More than 180independent subproblems were detected on average over the 41 instances. Bergner et al.(2015) develop techniques to automatically detect decomposable structure and test them on39 instances from MIBLIB 2003 and 2010 (Achterberg et al., 2006; Koch et al., 2011). Inthe best decomposable arrangement found for each of the 39 instances, the majority (26instances) had only linking constraints (i.e., no linking variables), which is the form of de-composable structure that we focus on in this paper. Out of those 26 instances, the linkingconstraints constituted less than 7% of the constraints in 23 cases, and less than 3% in 15cases. It is possible, of course, that even more instances have decomposable structure withfew linking constraints and no linking variables, but that the techniques of Bergner et al.(2015) found a different decomposable structure for them.
Several techniques have been developed for exploiting decomposable or nearly decompos-able structure, such as Lagrangian relaxation (Geoffrion, 1974), Dantzig-Wolfe decomposi-tion (Dantzig and Wolfe, 1960), and Benders decomposition (Benders, 1962). We note thatbranch-and-price (Barnhart et al., 1998), the application of Dantzig-Wolfe decomposition forthe solution of MIPs, requires carefully designed branching rules to preserve the structureof the pricing problem (Vanderbeck and Savelsbergh, 2006; Vanderbeck and Wolsey, 2010;Vanderbeck, 2011). The popularity and importance of branch-and-price in applications, inparticular, has initiated research into the automatic detection of decomposable structuresin MIPs, which has advanced significantly in recent years (Bergner et al., 2015; Kruberet al., 2017). Quite recently, decomposable structure has also been exploited in an approach
2
that uses an integer programming master problem derived from a multiobjective perspective(Bodur et al., 2016), as well as for generating cutting planes (Dey et al., 2017).
In the research described in this paper, we seek to use decomposable structure to define anew branching scheme. In their overview paper, Morrison et al. (2016) highlight that a greatas-yet-unexplored research direction when it comes to branching is different partitioningschemes:
“An important question here is: ‘How should the B&B algorithm branch in orderto generate the smallest number of unhelpful subproblems?’ In this context, anunhelpful subproblem is a subproblem that does not lead to any optimal or near-optimal solutions... [so it does] not provide any gain for the algorithm but maystill require substantial work to explore and prune. However, by consideringa different partitioning scheme for the branching strategy, it may be possibleto avoid exploring some of these unhelpful subproblems... Finally, it may bebeneficial to explore ‘hybrid’ binary-wide branching strategies, which employwide branching high in the search tree and switch to binary branching in lowerregions, or vice versa.” (Morrison et al., 2016)
As will become evident shortly, employing a different, wide partitioning scheme is exactlywhat decomposition branching does. However, it differs significantly from (the few) exist-ing approaches to wide branching. The branching rule by which decomposition branchingdivides the search space at a node of the branch-and-bound tree is determined by solving asubproblem, and the resulting branching constraints cannot be expressed without referenceto the value of the solution to the subproblem.
The idea of solving a subproblem to improve the performance of state-of-the-art branch-and-bound software (specifically, the SCIP software (Achterberg, 2009)) was exploited byGamrath et al. (2015) in their survey on progress in presolving for MIPs, mentioned above.They discuss a new technique called connected components, which identifies “small subprob-lems that are independent of the remaining part of the problem and tries to solve those tooptimality during the presolving phase”. Using this new preprocessing technique on the 41supply chain management instances led to an average reduction of over 18% in the numberof variables and of over 16% in the number of constraints. Solving (small) subproblems tooptimality is another key ingredient of decomposition branching.
More specifically, we propose an approach that exploits decomposable structure by branch-ing. The key idea is to better solve a large MIP by solving several smaller MIPs, exploitingembedded decomposable structure. We consider a MIP of the form
max∑i∈M
cixi (1)
s.t. xi ∈ Pi, ∀i ∈M (2)∑i∈M
Aixi ≤ b1, (3)∑i∈M
Dixi ≥ b2, (4)
3
where the input data is defined as follows: b1 ∈ Rm1+ , b2 ∈ Rm2
+ , m1,m2 ∈ Z+, and M :={1, . . . ,M} is the index set of blocks. For each i ∈ M, ci ∈ Rni , ni ∈ Z+ \ {0} andAi ∈ Rm×ni . We assume that Pi is nonempty and bounded for all i ∈ M, and representsintegrality requirements on the variables. For each block i ∈ M, the problem has m1 + m2
coupling constraints, linking different blocks together. The linking constraints (3) correspondto limits on a set of resources shared among the blocks; we refer to b1 as the resourcevector. Similarly, the linking constraints (4) correspond to a set of requirements that mustbe satisfied, collectively, by the blocks; we refer to b2 as the requirement vector.
Note that when m1 = m2 = 0 the problem is fully decomposable, so it can be solved bysolving M integer programs (of smaller sizes). For convenience, in the remainder, we assumethat m1 +m2 is relatively small, so the coefficient matrix is nearly decomposable.
A multi-objective optimization perspective lies at the heart of our approach, in which wethink of the linking constraints as additional objectives along with the true objective. Givena fractional solution to the MIP’s linear programming (LP) relaxation, the variables in eachblock satisfy the constraints for that block and contribute to the objective function and toeach of the linking constraints. We define a branching subproblem for each block, whichseeks an integer (feasible) solution that contributes “at least as much” to the linking con-straints and maximizes the block’s contribution to the objective function (for a maximizationproblem). If all branching subproblems yield (integer) solutions with the same contributionto the objective function as the current fractional solution, then these solutions must beoptimal for the current branch-and-bound node and one can stop exploring it. Else, at leastone of the branching subproblems provides a branching cut that eliminates the incumbentfractional solution.
In the following, we present the details of our approach (for a general MIP formulation).We then focus on two problems, a weighted set covering problem (Garey and Johnson, 2002)and a regionalized p-median facility location problem with assignment range constraints(Daskin and Tucker, 2018), to illustrate the implementation of the approach, to show itspotential, and to introduce extensions that improve its computational efficiency. Our com-putational study demonstrates the benefits of decomposition branching: it explores far fewernodes and can be orders of magnitude faster than existing state-of-the-art software.
The remainder of the paper is organized as follows. In Section 2, we introduce the prin-cipal ideas of decomposition branching. In Section 3, we show how decomposition branchingcan be used to solve instances of the weighted set covering problem. In Section 4, we discussenhancements that can result in significant performance improvements. In Section 5, wepresent the results of an extensive computational study. Finally, in Section 6, we presentsome final remarks.
2 Decomposition Branching
The approach exploits an observation based on parameterization of the right-hand side vec-tors, b1, b2, into partitions between the blocks. Specifically, the problem may be rewritten
4
as
maxM∑i=1
cixi
s.t. xi ∈ Pi, ∀i = 1, . . . ,M
Aixi ≤ ui, ∀i = 1, . . . ,M
Dixi ≥ `i, ∀i = 1, . . . ,M
M∑i=1
ui ≤ b1,
M∑i=1
`i ≥ b2,
where the variables, ui ∈ Rm1 and `i ∈ Rm2 for each i = 1, . . . ,M , are decomposition vectorsthat describe how the right-hand side vector is partitioned between blocks. This can bewritten equivalently as a resource-directive master problem (RDMP)
max {M∑i=1
fi(ui, `i) :M∑i=1
ui ≤ b1,M∑i=1
`i ≥ b2},
with subproblems SPi(y1, y2) defined by
fi(y1, y2) = max {ciξ : ξ ∈ Pi, Aiξ ≤ y1, Diξ ≥ y2},
for each i = 1, . . . ,M , where fi is the value function (with respect to block i’s component ofthe linking constraint) of the ith subproblem.
Our approach is predicated on the assumption that subproblems of the form of SPi arerelatively tractable to solve (perhaps even by a recursive application of this approach), andtheir solution is assumed to be a “black box” for the purpose of describing our approach.
It is not difficult to show that, without loss of generality, only solutions to the ith sub-problem that are nondominated points of the multi-objective optimization problem
max ciξ, minAi1ξ, . . .minAim1ξ,maxDi
1ξ, . . . ,maxDim2ξ
s.t. ξ ∈ Pi,
need be considered, where Aij denotes the jth row of Ai and Dij denotes the jth row of Di.
This is shown formally by Bodur et al. (2016), who use it to develop a new, resource-directive,reformulation of integer programs having decomposable structure. The reformulation has avariable for each nondominated point of a subproblem. Bodur et al. (2016) develop a solutionalgorithm for their reformulation, in which a modified form of column generation is used atthe first iteration to initialize an integer programming master problem, and the integerprogramming master problem is solved at each iteration thereafter.
5
In this paper, we propose to solve the original problem by branch-and-bound, in whichwe introduce the following new branching rule, which exploits the decomposable structurein the problem. Suppose the LP relaxation at some node of the tree has non-integer solutionx = (x1, . . . , xM) ∈ RM×N , where N =
∑Ni=1 ni. Also, let Pi ⊆ Pi denote the feasible set for
the ith subproblem at this node of the tree. For each i = 1, . . . ,M for which xi is non-integer(in some component that the MIP requires to be integer), solve the branching subproblem,BSPi(xi), given by
z∗i (xi) = max {ciξ : ξ ∈ Pi, Aiξ ≤ Aixi, Diξ ≥ Dixi}
to obtain solution ξ∗i . If xi is integer, set ξ∗i := xi. If it turns out that z∗i (xi) = cixi for everyi = 1, . . . ,M , then it must be that ξ∗ = (ξ∗1 , . . . , ξ
∗M) is an optimal solution for the current
node of the tree. Thus, the node is pruned by optimality. Otherwise, we may stop computingBSPi(xi) at the first i for which z∗i (xi) 6= cixi, in which case z∗i (xi) < cixi (otherwise x is notoptimal for the LP relaxation at this node of the tree). Suppose i is the first such branchingsubproblem. Then we propose the following branching rule:
cixi ≤ z∗i (xi) ∨m1∨j=1
(Aijxi > Aijxi) ∨m2∨j=1
(Dijxi < Di
jxi).
This gives a multi-way branch, with m1 +m2 + 1 child nodes, that cuts off xi.The implementation of a strict inequality in the branching rule is expected to make use
of a tolerance parameter, ε > 0, or integer rounding if the value of the left-hand side in thestrict inequality is known to be integer in any feasible solution. For example, to implementAijxi > Aijxi, add the constraint Aijxi ≥ Aijxi + ε to the formulation of Pi, or, if Aijxi is
known to be integer for all xi ∈ Pi, then add the constraint Aijxi ≥ dAijxie instead.Since this branching rule does not necessarily partition the node problem feasible set, it
can be strengthened by ordering the branching constraints, and adding the opposite of priorconstraints to each child node created. For example, when creating the child node for thebranching constraint Aijxi > Aijxi, the constraints
cixi > z∗i (xi) ∧j−1∧k=1
(Aikxi ≤ Aikxi)
may also be added. This leads us to propose a slightly more careful expression of thebranching subproblem, BSPi(xi), with double-sided bounds for each linking constraint andthe objective value, which may be written as
z∗i (xi) = max {ciξ : ξ ∈ Pi, αi ≤ cixi ≤ αi, βi ≤ Aiξ ≤ min{βi, Aixi}, µi ≥ Diξ ≥ max{µi, Dixi}}.
If Aijxi = βi
j then the branch for Aijxi > Aijxi can simply be eliminated. Similarly, ifDijxi = µi
jthen the branch for Di
jxi < Dijxi can be eliminated.
6
2.1 Special cases: linking constraints with set packing or set cov-ering structure
In the special case that some of the linking constraints take the form of either set packingor set covering constraints, in some block, then the out-degree of the branch-and-bound treenodes at which this block is used for branching can be reduced through standard binaryvariable modeling tricks. One branch can be used to model the branches for all linkingconstraints in the set packing form, and one branch can be used to combine all constraintsin the set covering form.
To be specific, suppose that for block i, it is known that Aijxi ∈ {0, 1} for any xi ∈ Pi, (soit can be guaranteed that 0 ≤ Aijxi ≤ 1), for all j = 1, . . . , q. Then, (assuming that Aijxi < 1for all j = 1, . . . , q, since otherwise the branch would be eliminated), the disjunction
q∨j=1
(Aijxi > Aijxi) =
q∨j=1
(Aijxi ≥ 1),
which can be modeled with the single constraint
q∑j=1
Aijxi ≥ 1.
This replaces q of the child nodes by a single child node.A similar situation occurs in set covering. When Di
jxi must take on binary values forsome block i, for all j = 1, . . . , q, (and assuming Di
jxi > 0 for all j) the disjunction
q∨j=1
(Dijxi < Di
jxi) =
q∨j=1
(Dijxi ≤ 0) =
q∨j=1
(Dijxi = 0),
which can be modeled with the single constraint
q∑j=1
Dijxi ≤ q − 1,
replacing q of the child nodes by a single child node.
3 Decomposition Branching for the Weighted Set Cov-
ering Problem
Although often stated in terms of sets, e.g., Karp (1972), here we state the set coveringproblem using a graph, as this makes the discussions about decomposition more transparent.We consider an undirected graph G = (V,E), with a weight, wv, for each vertex v ∈ V . Avertex v ∈ V , can be covered by itself or any other vertex u ∈ V such that (u, v) ∈ E. For
7
v ∈ V , we let δ(v) = {v} ∪ {u ∈ V : {u, v} ∈ E} denote v and its neighbors. For V ′ ⊆ V ,we let C(V ′) = {v ∈ V : v ∈ V ′ or {u, v} ∈ E with u ∈ V ′} =
⋃u∈V ′ δ(u) denote the set of
vertices that are covered by V ′. A set of vertices V ′ ⊆ V is called a cover (of G) if C(V ′) = V .The weight W (V ′) of a cover V ′ is W (V ′) =
∑v∈V ′ wv. The Weighted Set Covering problem
(WSC) is to find a minimum weight cover of a graph.Consider the following integer programming formulation of WSC:
min∑v∈V
wvxv (5)
s.t.∑u∈δ(v)
xu ≥ 1, ∀v ∈ V (6)
xv ∈ {0, 1}, ∀v ∈ V. (7)
Now consider a partition of the vertices, V1 ∪ V2 ∪ . . . VM = V . For each i ∈ M ={1, 2, . . . ,M}, the variables xv for v ∈ Vi form the variables of block i; each set Vi cor-responds to block i. We define Ui = {v ∈ Vi : δ(v) ⊆ Vi} for each i ∈ M to be the set ofvertices in Vi that can only be covered by vertices in the same block. Note that, for some i, itmay be that Ui = ∅. The feasible set for block i ∈M is defined by the coverage constraintsfor any vertex in Ui, i.e., by
Pi = {x ∈ {0, 1}Vi :∑u∈δ(v)
xu ≥ 1, ∀v ∈ Ui}.
The linking constraints are the coverage constraints for any vertex in V = V \ (⋃i∈M Ui). A
vertex in V is called a shared vertex. Define
Ni = {v ∈ V \ Ui : Vi ∩ δ(v) 6= ∅}
to be the set of nodes that may be covered by some node in Vi, but that may also be coveredby a node in Vj for some j 6= i.
In the multi-objective form of the block i subproblem, the objectives are the true objec-tive,
min∑v∈Vi
wvxv,
and, for each v ∈ Ni, the objective
max∑
u∈δ(v)∩Vi
xu.
To illustrate the decomposition branching subproblem for WSC, consider an example inwhich, for some block i, Ni = {v1, v2, v3, v4} and suppose that x, the initial solution to theLP relaxation, has∑
v∈Vi,v1∈δ(v)
xv = 1,∑
v∈Vi,v2∈δ(v)
xv = 2/3,∑
v∈Vi,v3∈δ(v)
xv = 2/3 and∑
v∈Vi,v4∈δ(v)
xv = 0.
8
Then the branching subproblem is
z∗i (x) = min{∑v∈Vi
wvxv : x ∈ Pi,∑
v∈Vi,vk∈δ(v)
xv ≥ 1, k = 1, 2, 3},
since the left-hand side of each covering expression must be integer, so the right-hand sidesin the constraints for k = 2, 3 can be set to d2/3e = 1. If z∗i (x) =
∑v∈Vi wvxv, then no
branching is needed from this subproblem; its integer solution could replace xv for v ∈ Vi toform an alternative optimal solution to the current LP relaxation, having fewer fractionalvariables. Otherwise, it must be that z∗i (x) >
∑v∈Vi wvxv, and the branching rule would be∑
v∈Vi
wvxv ≥ z∗i (x)∨ ∑
v∈Vi,v1∈δ(v)
xv = 0∨ ∑
v∈Vi,v2∈δ(v)
xv = 0∨ ∑
v∈Vi,v3∈δ(v)
xv = 0.
One way to ensure that these branches partition the solution space (and so form a poly-chotomy) is to add the constraints
∑v∈Vi,vk∈δ(v) xv ≥ 1 for all k = 1, 2, 3 to the first branch,
add constraint ∑v∈Vi,v1∈δ(v)
xv ≥ 1
to the latter two branches and add ∑v∈Vi,v2∈δ(v)
xv ≥ 1
to the last branch.
4 Enhancements
Decomposition branching repeatedly solves branching subproblems to obtain branching con-straints that cut off fractional solutions. Therefore, in order to improve the computationalefficiency, it is critical to generate these branching constraints as efficiently as possible andto obtain branching constraints that reduce the size of the search tree as much as possible.In this section, we discuss enhancements that seek to achieve this.
4.1 Constraint aggregation
As has already been noted, decomposition branching is likely to be polychotomous, ratherthan the usual dichotomous branching based on a single variable. For example, in the caseof WSC, after solving the branching subproblem for block i ∈M, decomposition branchingmay create up to |Ni|+1 branches. Here we introduce an enhancement that uses constraintaggregation to reduce the number of branches created at a node.
Constraint aggregation can be accomplished by designing nonnegative k1×m1 matrices,Si, for each i, with k1 ≤ m1, and nonnegative k2×m2 matrices, T i, for each i, with k2 ≤ m2.
9
We call Si (and T i) aggregation matrices. Then the aggregated branching subproblem for iis
α∗i (xi) = max {ciξ : ξ ∈ Pi, SiAiξ ≤ SiAixi, TiDiξ ≥ T iDixi}.
Choosing Si to be them1×m1 identity matrix would yield the original (first) set of constraints(similarly for T i). At the other extreme, taking Si to be the 1×m1 matrix of all ones wouldyield a single constraint in place of the (first) set of constraints. Some columns of Si (orT i) may be zero, allowing some of the linking constraints to be ignored altogether. Anysurrogate relaxation suffices. Of course, it is also possible, but not necessary, to use thesame aggregation matrices for all i.
Consider the situation when the above aggregated branching subproblem is solved toobtain solution ξ∗i . If Aiξ∗i ≤ Aixi and Diξ∗i ≥ Dixi and α∗i (xi) = cixi for every i = 1, . . . ,M ,then it must be that ξ∗ = (ξ∗1 , . . . , ξ
∗M) is an optimal solution for the current node of the tree.
Thus, the node is pruned by optimality. Otherwise, select i for which α∗i (xi) < cixi. If thereis no such i, then update one or more aggregation matrices so that the current subproblemsolution is no longer feasible, and re-solve the subproblem. We discuss possible updateprocedures in more detail below. Here, we observe that – provided the update procedure hasreasonable properties, e.g., after a finite number of updates, the aggregation matrix becomesthe identity matrix – this process must eventually either (i) prune the node by optimality(construct a complete integer feasible solution with the same objective value as that of theLP relaxation), or (ii) reach a situation in which α∗i (xi) < cixi for some i. Then the branchingrule we suggest is:
(cixi ≤ α∗i (xi)) ∨k1∨j=1
((SiAi)jxi > (SiAi)jxi) ∨k2∨j=1
((T iDi)jxi < (T iDi)jxi).
This gives a multi-way branch, with k1 + k2 + 1 child nodes, that cuts off xi.The most straightforward way to update an aggregation matrix is as follows. Suppose
the jth original constraint is violated by the current aggregated subproblem solution. Forexample, it may be that Aijξ
∗i > Aijxi. Then replace the jth column in the aggregation
matrix by a column of zeros, and add a new row, consisting of the jth unit vector in Rm1 .The effect of this operation is to remove the linking constraint j from the aggregation, andinclude it as a separate, individual, constraint. This could be done for some, or all, violatedconstraints, adding a new row for each. A more conservative approach would be to consideradding a single new constraint that aggregates some of the violated constraints: to add anaggregation of constraints indexed by J , replace the jth column in the aggregation matrixby a column of zeros, and then add a single row to it, consisting of the sum of the jth unitvectors over all j ∈ J .
We next show how constraint aggregation ideas can be used for WSC.
10
4.1.1 Constraint aggregation for weighted set covering
For WSC, one natural approach to constraint aggregation would be to select a subset S ⊆ Vand replace the linking constraint
∑v∈δ(u) xv ≥ 1 for each u ∈ S by the aggregation∑u∈S
∑v∈δ(u)
xv ≥ |S|. (8)
Note that we intend this replacement to occur only in the branching subproblem, not in themaster problem: the formulation of the LP relaxation is unchanged, except for the constraintsto be introduced by branching. Constraint (8) corresponds to taking the aggregation matrixT i to be the 1×|V | binary matrix that is the indicator vector of S, i.e., with T iv = 1 if v ∈ Sand T iv = 0 otherwise.
If S consists of nodes u with a large degree of overlap in their neighborhood sets, δ(u),then constraint (8) will not be a significant relaxation of the original constraints. To explainfurther, we note that differences in their neighborhood sets can result in constraint (8)“double counting” coverage of a vertex in S. For example, consider v, v′ distinct verticeswith v ∈ S and v′ ∈ δ(v) \ S having the property that v, v′ 6∈ δ(u) for all u ∈ S \ {v}. Thenonly one vertex in S, namely v, is covered by setting xv = 1 and xv′ = 1, but the left-handside of (8) will be at least xv + xv′ = 2. In the case that |S|= 2, this would satisfy (8) evenif only one of the two vertices in S (in particular, vertex v) is covered.
One simple way to address this issue is to introduce binary variables `iv for each blocki and shared vertex v ∈ V , to indicate whether or not block i is “responsible” for coveringvertex v. These variables now become part of the block i subproblem. We define their indexset Ni = {v ∈ V \ Ui : Vi ∩ δ(v) 6= ∅}, giving the set of shared vertices that can be coveredby some vertex in Vi. The variables for block i now consist of xv for each v ∈ Vi and `iv foreach v ∈ Ni, with the following feasible set (in place of Pi):
Qi = {(x, `i) ∈ {0, 1}Vi × {0, 1}Ni :∑v∈δ(u)
xv ≥ 1, ∀u ∈ Ui and∑
v∈Vi∩δ(u)
xv ≥ `iu, ∀u ∈ Ni}.
The role of (8) is now taken by ∑v∈S
∑i∈M,v∈Ni
`iv ≥ |S|,
and, in the multi-objective form of the branching subproblem for block i, the objective
max∑
v∈Ni∩S
`iv (9)
appears, in addition to the objective minimizing the total weight of vertices selected. Theabove objective seeks to maximize the number of vertices in S that are covered by block i.
Of course, more than one subset of linking constraints may be aggregated. For example,a heuristic could be used to partition V into a desired number of subsets. However, each
11
such subset would add one to the number of child nodes created at each branch-and-boundtree node by the resulting decomposition branching rule, increasing the tree nodes’ degrees.
We illustrate the WSC decomposition branching rule that would result from constraintaggregation over only a single subset of linking constraints, S, as follows. First, recall thatthe branching subproblem will seek to do “at least as well” as the fractional LP solution inrespect to each of the objectives derived from a linking constraint. Thus, given a fractionalLP solution, x, and a block i, we need to determine “how well” (xv)v∈Vi is covering verticesin S; we need to evaluate the left-hand side of constraint (9) and thus somehow need todetermine values of `iu for u ∈ Ni ∩ S that correspond to x. One simple expedient is toinclude the `iv variables in the master problem in the obvious way, and allow them to be setto values, ˆi
v, by the LP solver. This has an added advantage: such variables are required inthe master problem in order to model the branching constraints that result from constraintaggregation, as shall become obvious below. In what follows, we assume that ˆi
v values areavailable, found by this or some other means.
Consider an example in which, for some block i and set S ⊆ V , Ni ∩ S = {v1, v2, v3, v4}and suppose that ˆi, derived from the initial solution to the LP relaxation, has
4∑k=1
ˆivk
= 9/4.
Now the branching subproblem is
z∗i (x,ˆ) = min{
∑v∈Vi
wvxv : (x, `i) ∈ Qi,4∑
k=1
`ivk ≥ d4∑
k=1
ˆivke = 3}.
If z∗i (x,ˆ) >
∑v∈Vi wvxv, then the branching rule would be
∑v∈Vi
wvxv ≥ z∗i (x,ˆ)
∨ 4∑k=1
`ivk ≤ 2.
One way to ensure that these branches partition the solution space (and so form a dichotomy)is to add the constraint
∑4k=1 `
ivk≥ 3 to the first branch. Note that even if
∑4k=1
ˆivk
is already
integer, for example, it takes the value 3, then, since z∗i (x,ˆ) >
∑v∈Vi wvxv, this branching
rule cuts off the current LP solution.Clearly, branching constraints such as
∑4k=1 `
ivk≤ 2 or
∑4k=1 `
ivk≥ 3 cannot be added to
the master problem unless the ` variables are included in it.If z∗i (x,
ˆ) ≤∑
v∈Vi wvxv, then it is no longer the case that no branching from thissubproblem is needed. There is still the possibility that the subproblem solution has notcovered some particular, individual, shared vertex as well as the fractional solution did. Inthe next section, we describe the specific strategies we developed to address this issue, andto decide which subset(s) of linking constraints to aggregate, when.
12
4.1.2 A decomposition branching algorithm for WSC
Pseudocode for a decomposition branching with constraint aggregation algorithm for solvingWSC by branch-and-bound is presented in Algorithm 1. The algorithm is run at a nodeof the branch-and-bound tree, after the master problem LP relaxation has been solved andfound to be feasible, with one or more variables taking on non-integer values in the solution.Algorithm 1 takes as input the current fractional LP solution, consisting of the pair x and ˆ.It is assumed that all branching constraints and corresponding bounds on variables appliedto reach the current node have been included in the appropriate branching subproblem; wesignal this by writing Qi in place of Qi.
Our strategy is to apply constraint aggregation only to a block i for which ˆi containsfractional values. In this case, we first aggregate all linking constraints, and so take S = V .For an individual block, i, this is equivalent to aggregating all linking constraints over Ni,and results in the branching subproblem shown in lines 5 and 10 of Algorithm 1. If this failsto produce a branch, which occurs if z∗i (x,
ˆ) ≤∑
v∈Vi wvxv, then we take S to be a singleton,
consisting of one v for which ˆiv is fractional. The resulting subproblem is given at line 17,
and must produce a branch.If for some block i, ˆi contains only the values 0 or 1, but xv is fractional for some v ∈ Vi,
we revert to the unaggregated case, in which block i is required to cover all shared verticesthat it covers in the fractional solution. These vertices are indexed by the set F i, calculatedat line 22. The resulting branching subproblem is shown in line 23. The one additionalstrategy we employ is to maintain a dichotomous branching rule, by modeling the multiwaybranches ∨
v∈F i
(`iv = 0)
with the single constraint∑
v∈F i `iv ≤ |F i|−1, along the same lines as discussed for thespecial case of set covering in Section 2.1.
4.2 Re-using branching subproblem solutions
This enhancement is motivated by the observation that the same branching subproblem, orone with slightly different parameters, can arise at different nodes of the search tree. Thus,it is beneficial to store (relevant) information gathered during the solution of a branchingsubproblem and re-use it whenever possible during the search. To implement this enhance-ment, we define a set of states for a branching subproblem and maintain the best knownsolution for each of the states. Each time we solve a branching subproblem, we use thesolution obtained to update, if appropriate, the best known solution for one or more of thestates.
Recall that at a particular node of the search tree, the branching subproblem BSPi(xi),for i ∈M, can be written as
max {ciξ : ξ ∈ Pi, αi ≤ cixi ≤ αi, βi ≤ Aiξ ≤ min{βi, Aixi}, µi ≥ Diξ ≥ max{µi, Dixi}},
13
Algorithm 1: DB for WSC with constraints aggregation
Input: x, ˆ
1 foreach i ∈M with xv fractional for some v ∈ Vi do2 if ˆi
v is fractional for some v ∈ Ni then
3 σi :=∑
v∈Ni
ˆiv
4 if σi is fractional then
5 Calculate z∗i (x,ˆ) = min{
∑v∈Vi wvxv : (x, `i) ∈ Qi,
∑v∈Ni
`iv ≥ dσie}6 branch1 :
∑v∈Ni
`iv ≥ dσie∧ ∑
v∈Vi wvxv ≥ z∗i (x,ˆ)
7 branch2 :∑
v∈Ni`iv ≤ bσic
8 return
9 else
10 Calculate z∗i (x,ˆ) = min{
∑v∈Vi wvxv : (x, `i) ∈ Qi,
∑v∈Ni
`iv ≥ σi}11 if z∗i (x,
ˆ) >∑
v∈Vi wvxv then
12 branch1 :∑
v∈Ni`iv ≥ σi
∧ ∑v∈Vi wvxv ≥ z∗i (x,
ˆ)
13 branch2 :∑
v∈Ni`iv ≤ σi − 1
14 return
15 else
16 Choose some u ∈ N i with ˆiu fractional
17 Calculate z∗i (x,ˆ) = min{
∑v∈Vi wvxv : (x, `i) ∈ Qi, `
iu = 1}
18 branch1 : `iu = 1∧ ∑
v∈Vi wvxv ≥ z∗i (x,ˆ)
19 branch2 : `iu = 020 return
21 else
22 F i := {v ∈ Ni : ˆiv = 1}
23 Calculate z∗i (x,ˆ) = min{
∑v∈Vi wvxv : (x, `i) ∈ Qi, `
iv = 1, ∀v ∈ F i}
24 if z∗i (x,ˆ) >
∑v∈Vi wvxv then
25 branch1 : `iv = 1, ∀v ∈ F i∧ ∑
v∈Vi wvxv ≥ z∗i (x,ˆ)
26 branch2 :∑
v∈F i `iv ≤ |F i|−127 return
28 else29 Replace (xv)v∈Vi with the corresponding part of the solution of the
branching subproblem solved at line 23
14
where the branching constraints used to reach the current node of the search tree are encoded
in the bounds αi, αi, βi, βi, µi, and µi. Therefore, a state of a branching subproblem can be
defined as the set of intervals [αi, αi], [βi,min{βi, Aixi}], and [µi,max{µi, Dixi}]. This statedefinition may or may not be practical, because the number of states may be too large tomaintain and search efficiently.
However, alternative (aggregated) state definitions may be possible. For example, whensolving instances of WSC, we use the following two state definitions for the branching sub-problem for a given i ∈M.
• A Type 1 state associated with branching subproblem i is defined by an integer s ∈{0, . . . , |Ni|}, which represents the (minimum) number of shared vertices that have tobe covered in any solution to the branching subproblem.
• A Type 2 state associated with branching subproblem i is defined by a set S ⊂ Ni,where S represents a subset of shared vertices, every one of which must be covered inany solution to the branching subproblem.
The value stored for a state of either type can be used to avoid solving the branchingsubproblem in Algorithm 1 (in Lines 5, 10, 17 or 23).
4.3 Early termination of branching subproblem solving
To generate a branching constraint, it is not always necessary to solve a subproblem tooptimality. Instead of using the optimal solution value, an upper bound on the optimalsolution value (for a problem in maximization form) can be used to generate a branchingconstraint, if it cuts off the fractional solution to the master problem. Thus, one can considerterminating solution of a branching subproblem as soon as the value of the upper boundfalls below the value of the fractional solution to the master problem. Clearly, when solvinga branching subproblem to optimality is difficult, i.e., time consuming, early termination(especially early in the search process) may reduce overall solution time. Note that earlytermination can be combined with re-use of branching subproblem solutions (as discussedabove) by storing the best known upper bound value for a state.
4.4 Branching subproblem ordering
For a given fractional solution to the master problem, decomposition branching solves thesubproblems one by one to identify a constraint that eliminates the current fractional solutionto the master problem (or to construct a feasible solution with the same objective functionvalue). Thus, the order in which the branching subproblems are solved affects the search(and thus the solution time).
Certain subproblem orderings may work better for different problem classes and instances.For example, if solution times can differ significantly between branching subproblems, then
15
it may be beneficial to solve the branching subproblems in nondecreasing order of some “es-timate” of their solution time. Another consideration may be the likelihood that a branchingconstraint resulting from the solution to a subproblem will improve the dual bound.
The latter, for example, has motivated the subproblem ordering used when solving WSCinstances. Recall that at a node in the search tree, because of earlier branching decisions,an interval bounding the objective function value of subproblem i is known. In particular,for WSC, a lower bound, αi, on the value of branching subproblem i is known. We processthe branching subproblems in nondecreasing order of αi.
5 Computational experiments
In order to evaluate the effectiveness of decomposition branching (and the enhancementspresented to improve its computational efficiency), we have conducted a comprehensive nu-merical study with instances from two problems: WSC, which we have used above to il-lustrate many aspects of decomposition branching, and a regionalized form of the p-medianfacility location problem with assignment range constraints (Daskin and Tucker, 2018). Thechoice to use the latter is, in part, motivated by the fact that real-life instances were avail-able, but also because p-median facility location is another fundamental problem in discreteoptimization and this particular variant is especially hard to solve.
We implemented our algorithms using IBM ILOG CPLEX Studio 12.7 with Java. Allexperiments were run on 64-bit machine with an Intel Xeon E5-2650 v3 processor at 2.30GHz running Linux.
5.1 Weighted set covering
5.1.1 Instances
Each instance has M×n nodes, where M is the number of blocks and n the number of nodesin a block, so V = V1 ∪ V2, . . . ∪ VM with |Vi|= n for all i = 1, . . . ,M . The node weightsare drawn from the set {1, . . . ,W} with equal probability. Each block has bρn(n − 1)/2cedges between its nodes, where ρ ∈ (0, 1] represents the block density. Furthermore, s×Medges connect different blocks, where s ∈ {1, . . . , n} is a parameter representing the blockconnectivity. More specifically, the edge set E is generated as follows.
• For each block, we generate a random Hamiltonian cycle and add its n edges to E.
• For each block, we randomly pick distinct pairs of nodes and add the edge connectingthem to E until we have added bρn(n−1)/2c−n distinct edges (duplicates are skipped).
• For each block i = 1, . . . ,M , we randomly pick a set Ci ⊆ Vi of s nodes. Then for eachi = 1, . . . ,M and for each node in Ci, we randomly pick a node in V1 \C1 ∪ . . .∪Vi−1 \Ci−1 ∪ Vi+1 \Ci+1 ∪ . . .∪ VM \CM and add the edge connecting the two selected nodesto E, again ensuring no duplicate edges are created.
16
5.1.2 Implementation
The master problem at a node is
min∑v∈V
wvxv
s.t. ((xv)v∈Vi , `i) ∈ Qi, ∀i ∈M∑
i∈M,v∈Ni
`iv = 1, ∀v ∈ V
together with all branching constraints added to create the node, where
Qi = {(x, `i) ∈ {0, 1}Vi × {0, 1}Ni :∑v∈δ(u)
xv ≥ 1, ∀u ∈ Ui and∑
v∈Vi∩δ(u)
xv ≥ `iu, ∀u ∈ Ni}.
What we will refer to as the basic implementation follows Algorithm 1 and uses thetwo forms of branching subproblem solution re-use discussed in Section 4.2. Preliminaryexperiments have shown that for these instances, the branching subproblems solve quite fastand an optimal solution is found quite early in the search. However, the (global) lower boundimproves only slowly. As a result, the order in which the branching subproblems are solvedhas a significant impact on the overall performance, and always processing the subproblemsin nonincreasing order of the best known bound on the objective function value, as suggestedin Section 4.4, provided the best results. What we will refer to as the enhanced version usesthis subproblem ordering. Because the branching subproblems solve quickly, there is no needto incorporate early termination ideas.
5.1.3 Experiments
Among the instance parameters, M and s are the most relevant when it comes to determiningthe potential of decomposition branching. As M increases and as s decreases, the benefit ofdecomposition branching should increase. In our experiments, we set n = 150, ρ = 0.3 andW = 5, consider all combinations of M ∈ {4, 6, 8} and s ∈ {2, 3, 4}, generate five randominstances for each combination, and impose a run time limit of 7200 seconds.
5.1.4 Analysis
The results of our experiments can be found in Table 1, where we compare the performanceof decomposition branching (DB) and its enhancement with branching subproblem ordering(DB-E) to the performance of commercial solver CPLEX. In the table, we report the run timein seconds averaged over the five random instances (column headed time), the optimalitygap averaged over the five random instances (column headed gap), the number of times anoptimal solution is found (and proved to be optimal) for the five random instances (columnheaded #opt), and the number of nodes explored during the search averaged over the fiverandom instances (column headed #BB). Note that the number of nodes explored during
17
Table 1: Results for WSC instances.
CPLEX DB DB-E
M s time gap #opt #BB time gap #opt #BB time gap #opt #BB
4 2 6660.4 0.07 1 43763096.8 32.4 0.000 5 613.4 9.2 0.000 5 47.23 6341.8 0.07 1 34432090.4 43.4 0.000 5 770.6 12.6 0.000 5 104.04 6190.0 0.08 1 38250411.4 60.8 0.000 5 1318 10.6 0.000 5 53.6
6 2 7205.6 0.16 0 22636545.2 65.4 0.000 5 2123.2 15.2 0.000 5 146.03 7204.8 0.16 0 16732260.0 329.0 0.000 5 21051.8 37.6 0.000 5 486.64 7206.4 0.16 0 14712223.0 896.8 0.000 5 66249.8 80.6 0.000 5 1147.2
8 2 7206.6 0.20 0 12335430.4 446.2 0.000 5 47400.8 34.6 0.000 5 992.43 7205.0 0.20 0 15277503.0 5432.0 0.030 2 606648.4 185.8 0.000 5 7662.44 7206.0 0.20 0 11573046.8 7200.0 0.091 0 484541.0 2758.0 0.003 4 105625.4
the search does not include the number of nodes explored during the solution of the branchingsubproblems (these numbers can be found in Table 2).
The results clearly demonstrate the benefits of decomposition branching (for these in-stances). Decomposition branching finds an optimal solution in all but eight of the instanceswithin the time limit, whereas CPLEX only solves three instances within the time limit.Note too that when CPLEX fails to find an optimal solution, the gaps are not small (around20% for the larger instances). The difference in solution times is also striking. For theinstances solved by both algorithms, decomposition branching is sometimes more than 200times faster than CPLEX. The reason is obvious: decomposition branching results in drasti-cally smaller search trees. As expected, the solution times for decomposition branching startto increase when instances get larger, especially when the block connectivity (s) increasesand decomposition branching needs to explore more nodes to converge.
The results also show the impact of the order in which the branching subproblems areprocessed. When processing branching subproblems in nondecreasing order of the currentlower bound on their objective function value, only a single instance cannot be solved tooptimality within the time limit (as opposed to eight when branching subproblems are pro-cessed in the order in which they appear in the formulation). Furthermore, the enhancedversion is around 10 times faster, where the difference is more pronounced for instances witha larger number of blocks (M) and a larger block connectivity (s) (up to 29 times faster, inthe case of M = 8, s = 3). Such instances have a larger root gap and hence improving their(global) lower bound faster is critical.
In Table 2, we present further details related to the performance of DB and DB-E.For each instance solved with each algorithm, we record (i) the average run time spent insolving branching subproblems, in seconds, (ii) the total number of branching subproblemsthat were solved, (iii) the number of times solving a branching subproblem was avoidedbecause of information stored from previous subproblem solves, and (iv) the total numberof nodes processed while solving branching subproblems, not counting root nodes. (Thenumber of nodes to solve a branching subproblem is taken to be zero if it solves at theroot node.) Table 2 shows, in each row, the average of (i), (ii), (iii) and (iv) over the 5instances represented by the row in the columns headed sub.time, #subSolve, #stateUsed,
18
and #subBB, respectively. The column headed time duplicates the total run time in seconds,averaged over all instances represented by the row, given in Table 1.
Table 2: DB and DB-E solution details for WSC instances.
DB DB-E
M s time sub.time #subSolve #stateUsed #subBB time sub.time #subSolve #stateUsed #subBB
4 2 32.4 0.23 127.8 837.0 125.8 9.2 0.35 21.6 24.2 211.23 43.4 0.30 132.6 1169.0 489.8 12.6 0.36 29.2 103.0 172.04 60.8 0.28 194.6 2045.8 855.4 10.6 0.36 20.4 26.0 151.2
6 2 65.4 0.24 220.2 4790.2 1013.4 15.2 0.33 30.8 115.0 279.83 329.0 0.20 1034.8 43516.2 4754.6 37.6 0.31 60.0 443.4 429.44 896.8 0.18 2876.0 136859.4 7326.0 80.6 0.32 83.6 1154.4 601.8
8 2 446.2 0.21 858.0 170432.4 847.6 34.6 0.32 62.8 1183.8 589.63 5432.0 0.18 4827.8 2049653.4 4618.2 185.8 0.31 157.8 10593.2 965.04 7200.0 0.16 11040.4 1951035.8 6407.8 2758.0 0.27 383.0 129264.0 870.4
Most importantly, we see that the time required to solve a branching subproblem, onaverage, is very small. Even though the branching subproblem is, essentially, a weightedset cover problem, it has a much smaller set of nodes compared to the set of nodes definingthe full instance. While CPLEX cannot solve a full instance within the time limit of 7200seconds (in most cases), it can solve the branching subproblems in less than one second.This highlights the fundamental premise and advantage of decomposition branching: solvinga large MIP by solving a sequence of small MIPs can be much faster than solving the largeMIP directly. For the WSC instances, both the number of branching subproblems solvedand the time required to solve them are quite small, and, hence, decomposition branchingperforms much better than traditional branch-and-bound. Furthermore, we see that storingand re-using subproblem solutions (which is done in both variants) is critical, especiallywhen the instances get larger. The number of times branching subproblem state informationcan be used to avoid solving a branching subproblem increases rapidly when the instancesget larger and more difficult to solve. Without this enhancement, decomposition branchingmight not have been able to solve as many instances as it has.
The results also reveal the benefits of the subproblem ordering employed in DB-E, namely,of processing the branching subproblems in nondecreasing order of their current objectivelower bound value. On average, the branching subproblem solution times are higher, butthe drastic reduction in the number of nodes in the search tree easily makes up for this.
5.2 p-median facility location with assignment range constraints
In this section, we analyze the computational performance of branching decomposition (andits suggested enhancements) when solving instances of a regionalized variant of the p-medianfacility location problem with assignment range constraints investigated by Daskin andTucker (2018). The formulation used in our computational experiments is given below. Themain difference with the formulation of Daskin and Tucker (2018) is that we have introducedregions so as to have a natural nearly-decomposable structure.
19
We are given a set of regions R, a set of demand points I, with Ir the set of demandpoints in region r ∈ R, a set of candidate facility locations J , with Jr the set of candidatefacility locations in region r ∈ R, a quantity hi at demand point i ∈ I, distances dij betweendemand point i ∈ I and facility location j ∈ J , the maximum number p of facilities to locate,and the maximum allowable range of assigned demands to a facility in a region, ρmax. Weintroduce the following decision variables: xj, a binary variable indicating whether a facilityis opened at location j ∈ J or not, yij, a binary variable indicating whether a demand pointi ∈ I is assigned to a facility at location j ∈ J or not, Ur, the maximum demand assignedto any of the open facilities in region r ∈ R, and Lr the minimum demand assigned to anyof the open facilities in region r ∈ R.
With these inputs and decision variables, our variant of the p-median facility locationproblem with assignment range constraints (FLAR) can be formulated as follows (where Mr
is a suitably chosen constant):
min∑i∈I
∑j∈J
hidijyij
s.t.∑j∈Jr
yij ≥ 1 ∀r ∈ R, i ∈ Ir
yij ≤ xj ∀r ∈ R, i ∈ Ir, j ∈ Jr∑j∈J
xj ≤ p
Ur ≥∑i∈Ir
hiyij ∀r ∈ R, ∀j ∈ Jr
Lr ≤∑i∈Ir
hiyij +Mr(1− xj) ∀r ∈ R, ∀j ∈ Jr
Ur − Lr ≤ ρmax ∀r ∈ Rxj ∈ {0, 1} ∀j ∈ Jyij ∈ {0, 1} ∀r ∈ R, i ∈ Ir, j ∈ Jr.
The last three constraints capture the assignment range constraints and limit the differencebetween the maximum demand assigned to a facility in a region and the minimum demandassigned to a facility in a region.
There is just a single constraint linking the regions, namely the one that limits the numberof facilities that can be opened across the regions.
5.2.1 Instances
We generate instances using the 150-city and 880-city data sets from Daskin and Tucker(2018). To partition the cities into regions, we use the region and division definitions of theUnited States Census Bureau (United States Census Bureau). In Figure 1, we illustrate the
20
partitions of the cities for the two data sets. More information on the region and divisiondefinitions can be found in Table 5 in Appendix A.
−120 −110 −100 −90 −80 −70
2530
3540
45
c150$lat
c150$lon
(a) Partition of the 150 node US data set intofour census regions.
−120 −110 −100 −90 −80 −70
2530
3540
45
−c880$long
c880$lat
(b) Partition of the 880 node US data setinto nine census regions.
Figure 1: Region definitions.
For the 150-city data set, we consider two instances: one with four and one with nineblocks (corresponding to US census regions and divisions, respectively). For the 880-city dataset, we consider a single instance with nine blocks (corresponding to US census divisions).
5.2.2 Implementation
Because FLAR has only a single linking constraint, there is no need for constraint aggrega-tion. On the other hand, as Figure 1 shows (and Table 5 does so even more clearly), thenumber of cities in a region can differ widely. Branching subproblems with fewer cities arelikely to be easier to solve. Therefore, in what we refer to as the basic version of decomposi-tion branching (DB), we process branching subproblems in nondecreasing order of size (i.e.,the number of cities in the associated region). Preliminary experiments also revealed thatsome of the branching subproblems take quite a long time to solve. Therefore, in what werefer to as the enhanced version of decomposition branching (DB-E), we also incorporate anearly termination strategy. To describe this strategy in detail, we introduce the followingnotation.
A branching subproblem is completely characterized by the region, r, and the maximumnumber of facilities allowed to be opened, u. We let S(r, u) and S(r, u) denote the best knownlower and upper bound values, respectively, on the objective function value of a branchingsubproblem, for r ∈ R and u ∈ {1, . . . , p − (|R|−1)} (because at least one facility has tobe opened in each region). Furthermore, we let zr(u, t, g) and zr(u, t, g) denote the bestupper and lower bounds found when solving the branching subproblem for region r for t > 0seconds, or, if at time t the optimality gap is still greater than target g, until the time thatthe optimality gap drops below g. Finally, let Solve(r, u, t, g) denote the process of solvingbranching subproblem r with control parameters u, t, and g. Note that when Solve(r, u, t, g)terminates, the gap between zr(u, t, g) and the optimal value for the branching subproblemfor region r, restricted to at most u facilities, is guaranteed to be no more than g.
21
As mentioned above, the regions are processed in nondecreasing order of the number ofdemand points they contain. Given a fractional solution (x, y) at a node in the search tree,the value of the best known feasible solution to the master problem, zUB, and its associatedoptimality gap, g = 1 −
∑i∈Ir
∑j∈Jr
hidijyij/zUB, the steps taken by the enhanced version ofdecomposition branching are presented in Algorithm 2.
Algorithm 2: DB-E for FLAR.Input: x, y, zUB , g
1 foreach r ∈ R do2 Set X :=
∑j∈Jr
xj
3 foreach r ∈ R do4 if X is fractional then
5 if(1− S(r, bXc)/S(r, bXc)
)> 0.1 then
6 Solve(r, bXc, t, 0.1)7 S(r, bXc) := max{zr(bXc, t, 0.1), S(r, bXc)}8 S(r, bXc) := min{zr(bXc, t, 0.1), S(r, bXc)}
9 branch1 :∑
j∈Jrxj ≥ dXe
10 branch2 :∑
j∈Jrxj ≤ bXc
∧ ∑i∈Ir
∑j∈Jr
hidijyij ≥ S(r, bXc)11 return
12 foreach r ∈ R do13 if S(r, X) >
∑i∈Ir
∑j∈Jr
hidij yij then
14 branch1 :∑
j∈Jrxj ≥ X + 1
15 branch2 :∑
j∈Jrxj ≤ X
∧ ∑i∈Ir
∑j∈Jr
hidijyij ≥ S(r, X)
16 return
17 foreach r ∈ R do
18 if(1− S(r, X)/S(r, X)
)> g then
19 Solve(r, X, t, g)20 S(r, bXc) := max{zr(bXc, t, g), S(r, bXc)}21 S(r, bXc) := min{zr(bXc, t, g), S(r, bXc)}22 if S(r, X) >
∑i∈Ir
∑j∈Jr
hidij yij then
23 branch1 :∑
j∈Jrxj ≥ X + 1
24 branch2 :∑
j∈Jrxj ≤ X
∧ ∑i∈Ir
∑j∈Jr
hidijyij ≥ S(r, X)
25 return
26 zUBnew := 0
27 foreach r ∈ R do28 Solve(r, X, t, 0)29 S(r, X) := zr(X, t, 0)
30 S(r, X) := zr(X, t, 0)31 if S(r, X) >
∑i∈Ir
∑j∈Jr
hidij yij then
32 branch1 :∑
j∈Jrxj ≥ X + 1
33 branch2 :∑
j∈Jrxj ≤ X
∧ ∑i∈Ir
∑j∈Jr
hidijyij ≥ S(r, X)
34 return
35 else
36 zUBnew := zUB
new + S(r, X)
37 if zUBnew < zUB then
38 zUB := zUBnew
The algorithm first checks, for each of the branching subproblems, if the sum of the valuesof the decision variables indicating whether or not a facility is opened in the current solutionto the master problem, denoted by X, is fractional. If so, then the branching constraints
22
∑j∈Jr xj ≥ dXe for one branch and
∑j∈Jr xj ≤ bXc for the other, form a dichotomy that
cuts off the fractional solution. In this case, since the branching subproblem value is notessential to determining branching constraints, the latter branch is strengthened throughthe use of a lower bound known to be within 10% of optimality, rather than with the trueoptimal value of the branching subproblem.
If X is integer for all branching subproblems, then the algorithm checks, for each ofthe subproblems, if there is a stored subproblem lower bound that provides a branchingconstraint on the objective function value that eliminates the current solution to the masterproblem. If the algorithm encounters such a stored subproblem lower bound, it uses it tobranch.
If none of the branching subproblems has a stored lower bound that provides a branchingconstraint, then the algorithm seeks a branching subproblem that, when solved to a smalleroptimality gap than the current master problem gap, g, yields a lower bound whose associatedbranching constraint cuts off the current master problem solution.
Finally, the algorithm solves the subproblems to optimality to find a branching constrainton the objective function value that eliminates the current solution to the master problem.If no such branching constraint can be found for any of the subproblems, then a feasiblesolution to the master problem has been identified. The algorithm updates the best knownfeasible solution, if necessary, and then fathoms the node.
5.2.3 Experiments
For the maximum number of facilities to open, p, we consider p ∈ {6, 9, 12, . . . , 30} for theinstance with four regions and p ∈ {12, 15, . . . , 30} for the instances with nine regions. Forthe 150-city instances, we use assignment range limit ρmax = 100, 000 and for the 880-cityinstances, we use assignment range limit ρmax = 600, 000.
The overall time limit for the 150-city and 880-city instances are set to 10,800 and 36,000seconds, respectively. For the branching subproblem solution time limit, we use t = 25seconds, for the instances derived from the 150-city data set, and t = 150 seconds for theinstance derived from the 880-city data set.
5.2.4 Analysis
The results of our experiments can be found in Table 3, where we compare the performance ofCPLEX to the performance of the two variants of decomposition branching. The informationpresented is the same as in Table 1. Here we use “TL” to indicate that the time limit allowedfor this instance was reached.
The results demonstrate the superior performance of decomposition branching, especiallythe variant that incorporates early termination, DB-E. Even DB outperforms CPLEX foralmost all instances (except for the 880-city instances with p = 15, 18, and 30). It is alsoclear that incorporating early termination provides significant benefits, noticeably reducingthe solution time and finding optimal solutions for three of the four instances where DBfailed to do so.
23
Table 3: Results for FLAR instances.
CPLEX DB DB-E
prob M p time #BB gap time #BB gap time #BB gap
150 City 4 6 98 248169 0.000 26 11 0.000 19 13 0.0009 1004 1997375 0.000 118 29 0.000 44 19 0.000
12 5505 7653957 0.000 277 47 0.000 104 49 0.00015 TL 5165615 0.036 1171 51 0.000 222 63 0.00018 TL 2540444 0.019 1756 55 0.000 646 95 0.00021 TL 1370675 0.008 1977 73 0.000 508 139 0.00024 TL 1846260 0.009 1368 65 0.000 892 255 0.00027 TL 2014879 0.010 1978 105 0.000 914 305 0.00030 TL 2115462 0.014 1886 173 0.000 1676 273 0.000
9 12 29 75909 0.000 8 61 0.000 9 63 0.00015 241 909125 0.000 12 136 0.000 11 145 0.00018 4291 6363910 0.000 46 677 0.000 35 548 0.00021 TL 12260069 0.014 109 1854 0.000 62 1332 0.00024 TL 10733786 0.017 111 1954 0.000 105 1987 0.00027 TL 10196558 0.023 163 3039 0.000 123 3463 0.00030 TL 9444625 0.012 131 2016 0.000 144 3186 0.000
880 City 9 12 1289 89001 0.000 1236 27 0.000 823 21 0.00015 8700 725120 0.000 TL 130 0.030 6613 31 0.00018 TL 2603775 0.001 TL 72 0.087 6165 27 0.00021 TL 3162819 0.043 26741 1019 0.000 17205 123 0.00024 TL 3162790 0.068 34566 3858 0.000 25014 697 0.00027 TL 2585364 0.075 TL 498 0.067 TL 1159 0.02030 TL 3361937 0.076 TL 109 0.094 26681 3737 0.000
Table 4 presents further details about the computational performance of DB and DB-E. The column headings have the same meaning as in Table 2, but with #subSolve nowcounting how many times the function Solve() is executed.
The results clearly show that, unlike for the WSC instances, solving the branching sub-problems is challenging and time-consuming. For the 150-city instances, the branching sub-problems can still be solved in a reasonable of time, but for the 880-city instances solving thebranching subproblems becomes computationally prohibitive without the early-terminationenhancement. This is evident from the instances for p = 27 and p = 30. Even though a timelimit of 36,000 was imposed, the instances finished after more than 53,000 seconds, indicat-ing that the solution of the last branching subproblem took more than 17,000 seconds. (Inthe implementation, the time limit is checked only at the highest level and not during theexecution of the subroutines).
6 Final remarks
Our computational experiments with WSC and FLAR provide orthogonal perspectives onthe performance of decomposition branching. In the former, the branching subproblemsare easy to solve, and the linear programming bound is weak, whereas in the latter, thebranching subproblems are hard to solve, but the linear programming bound is strong.The results demonstrate that in both cases decomposition branching can provide significant
24
Table 4: DB and DB-E solution details for FLAR instances.
DB DB-E
prob M p #subSolve #stateUsed sub.time time #subBB #subSolve #stateUsed sub.time time #subBB
150 City 4 6 7 12 1.4 26 7761 6 6 1.6 19 77619 13 58 4.1 118 76126 10 6 3.5 44 30207
12 13 128 17.9 277 264246 14 9 6.3 104 11376115 16 132 71.7 1171 796344 17 18 11.7 222 38475118 19 136 91.7 1756 1081252 23 45 25.0 646 59947121 26 183 75.1 1977 1181368 29 53 14.6 508 36602124 25 164 53.6 1368 772358 35 170 17.7 892 34551927 28 286 69.4 1978 854018 39 220 17.4 914 43770530 35 516 52.0 1886 877043 55 258 28.1 1676 698941
9 12 16 248 0.3 8 496 16 25 0.3 9 49615 22 724 0.3 12 1728 22 45 0.3 11 172618 32 3392 0.5 46 27202 32 130 0.5 35 2796921 37 8455 1.1 109 171408 36 281 0.7 62 5987924 39 7819 1.0 111 167584 40 476 1.1 105 17168427 40 10665 1.1 163 173840 39 1086 1.1 123 17160230 45 8658 1.0 131 192318 43 940 1.0 144 194643
880 City 9 12 12 61 12.9 1236 91015 12 16 12.2 823 9101515 24 755 14.2 36000 166099 15 24 14.4 6613 15359418 26 543 100.3 36000 554158 16 12 14.0 6165 15359421 36 5360 408.0 26741 2289219 25 37 549.4 17205 273797824 47 20558 215.2 34566 2562405 40 460 429.9 25014 434776727 40 3954 1198.2 59082 7543266 47 440 607.6 36000 932230130 37 850 1306.2 53118 7889848 57 998 175.1 26681 4868190
computational advantages over simply handing an instance over to a commercial solver.Even though the initial computational results have far exceeded our expectations regard-
ing the potential of decomposition branching, more research and experimentation is neededto fully understand and assess its benefits and how to best implement it. One of the inter-esting avenues for further research is to investigate recursive application of decompositionbranching.
25
References
T. Achterberg. Scip: solving constraint integer programs. Mathematical Programming Com-putation, 1(1):1–41, 2009.
T. Achterberg, T. Koch, and A. Martin. Branching rules revisited. Operations ResearchLetters, 33(1):42–54, 2005.
T. Achterberg, T. Koch, and A. Martin. Miplib 2003. ORL, 34(4):361–372, 2006.
D. Applegate, R. Bixby, V. Chvatal, and W. Cook. Finding cuts in the tsp, 1995.
C. Barnhart, E. L. Johnson, G. L. Nemhauser, M. W. Savelsbergh, and P. H. Vance. Branch-and-price: Column generation for solving huge integer programs. Operations research, 46(3):316–329, 1998.
J. F. Benders. Partitioning procedures for solving mixed-variables programming problems.Numerische Mathematik, 4:238–252, 1962.
M. Benichou, J.-M. Gauthier, P. Girodet, G. Hentges, G. Ribiere, and O. Vincent. Ex-periments in mixed-integer linear programming. Mathematical Programming, 1(1):76–94,1971.
M. Bergner, A. Caprara, A. Ceselli, F. Furini, M. E. Lubbecke, E. Malaguti, and E. Traversi.Automatic dantzig–wolfe reformulation of mixed integer programs. Mathematical Program-ming, 149(1-2):391–424, 2015.
R. Bixby. A brief history of linear and mixed-integer programming computation. DocumentaMath. Extra Volume: Optimization Stories, pages 107–121, 2012.
M. Bodur, S. Ahmed, N. Boland, and G. L. Nemhauser. Decomposition of loosely coupledinteger programs: A multiobjective perspective. Optimization Online, 2016.
M. Conforti, G. Cornuejols, and G. Zambelli. Integer Programming. Springer, 2014.
G. B. Dantzig and P. Wolfe. Decomposition principle for linear programs. Operations Re-search, 8:101–111, 1960.
M. S. Daskin and E. L. Tucker. The trade-off between the median and range of assigneddemand in facility location models. International Journal of Production Research, 56(1-2):97–119, 2018.
S. S. Dey, M. Molinaro, and Q. Wang. Analysis of sparse cutting planes for sparse milpswith applications to stochastic milps. Mathematics of Operations Research, 43(1):304–332,2017.
B. Dilkina, E. B. Khalil, and G. L. Nemhauser. Comments on: On learning and branching:a survey. TOP, 25(2):242–246, 2017.
26
G. Gamrath, T. Koch, A. Martin, M. Miltenberger, and D. Weninger. Progress in presolvingfor mixed integer programming. Mathematical Programming Computation, 7(4):367–398,2015.
M. R. Garey and D. S. Johnson. Computers and intractability, volume 29. wh freeman NewYork, 2002.
A. M. Geoffrion. Lagrangian relaxation for integer programming. Mathematica; ProgrammingStudy, 2:82–114, 1974.
M. Junger, T. Liebling, D. Naddef, G. Nemhauser, W. Pulleyblank, G. Reinelt, G. Rinaldi,and L. Wolsey. 50 Years of Integer Programming 1958-2008. Springer, 2010.
R. M. Karp. Reducibility among combinatorial problems. In Complexity of computer com-putations, pages 85–103. Springer, 1972.
E. B. Khalil, P. Le Bodic, L. Song, G. L. Nemhauser, and B. N. Dilkina. Learning to branchin mixed integer programming. In AAAI, pages 724–731, 2016.
T. Koch, T. Achterberg, E. Andersen, O. Bastert, T. Berthold, R. E. Bixby, E. Danna,G. Gamrath, A. M. Gleixner, S. Heinz, et al. Miplib 2010. MPC, 3(2):103, 2011.
M. Kruber, M. E. Lubbecke, and A. Parmentier. Learning when to use a decomposition.In International Conference on AI and OR Techniques in Constraint Programming forCombinatorial Optimization Problems, pages 202–210. Springer, 2017.
A. H. Land and A. G. Doig. An automatic method of solving discrete programming problems.Econometrica, 28:497–520, 1960.
P. Le Bodic and G. L. Nemhauser. How important are branching decisions: fooling mipsolvers. Operations Research Letters, 43(3):273–278, 2015.
J. T. Linderoth and M. W. Savelsbergh. A computational study of search strategies formixed integer programming. INFORMS Journal on Computing, 11(2):173–187, 1999.
A. Lodi and G. Zarpellon. On learning and branching: a survey. TOP, 25(2):207–236, 2017.
D. R. Morrison, S. H. Jacobson, J. J. Sauppe, and E. C. Sewell. Branch-and-bound al-gorithms: A survey of recent advances in searching, branching, and pruning. DiscreteOptimization, 19:79–102, 2016.
G. Nemhauser and L. Wolsey. Integer and Combinatorial Optimization. John Wiley & Sons,1988.
A. Schrijver. Theory of linear and integer programming. John Wiley & Sons, 1998.
27
United States Census Bureau. Census regions and divisions of the united states. https:
//www2.census.gov/geo/pdfs/maps-data/maps/reference/us_regdiv.pdf. Accessed:2018-07-16.
F. Vanderbeck. Branching in branch-and-price: a generic scheme. Mathematical Program-ming, 130(2):249–294, 2011.
F. Vanderbeck and M. W. Savelsbergh. A generic view of dantzig–wolfe decomposition inmixed integer programming. Operations Research Letters, 34(3):296–306, 2006.
F. Vanderbeck and L. A. Wolsey. Reformulation and decomposition of integer programs. In50 Years of Integer Programming 1958-2008, pages 431–502. Springer, 2010.
L. Wolsey. Integer Programming. John Wiley & Sons, 1998.
28
Appendix A Partition of cities into United States cen-
sus regions and divisions
Table 5 details the partition of the cities in the two data sets into United States censusregions and divisions (United States Census Bureau).
Table 5: Partition of cities into United States census regions and divisions.
Number of Cities
Region Division 150 node 880 node
Northeast New England 7 58Middle Atlantic 10 117
South South Atlantic 25 144East South Central 11 73West South Central 21 91
MidWest East North Central 18 117West North Central 11 114
West Mountain 16 86Pacific 31 80
29
