the prize collecting steiner tree problem
TRANSCRIPT
The Prize Collecting Steiner Tree Problem
by
Maria MinkoffS.B., Mathematics with Computer Science (1998)
MIT
Submitted to the Department of Electrical Engineering and Computer Sciencein partial fulfillment of the requirements for the degree of
Master of Science in Electrical Engineering and Computer Science
at the
MASSACHUSETTS INSTITUTE OF TECHNOLOGY
June 2000
0 Massachusetts Institute of Technology 2000. All rights reserved.
A uthor ............. ... ........Department of Electrical Engineering'ad Computer Science
May 19, 2000
Certified by....David R. Karger
Associate Professi'f Computer Science and EngineeringThesis Supervisor
Accepted by...............Arthur C. Smith
Chairman, Department Committee on Graduate Students
OF TECHNOLOGY
ENG JUN 2 12 Z000
1 LIBRARIES
The Prize Collecting Steiner Tree Problem
by
Maria Minkoff
S.B., Mathematics with Computer Science (1998)
MIT
Submitted to the Department of Electrical Engineering and Computer Scienceon May 19, 2000, in partial fulfillment of the
requirements for the degree ofMaster of Science in Electrical Engineering and Computer Science
Abstract
This work is motivated by an application in local access network design that can be modeledusing the KP-hard Prize Collecting Steiner Tree problem. We consider several variants onthis problem and on the primal-dual 2-approximation algorithm devised for it by Goemansand Williamson. We develop several modifications to the algorithm which lead to theoreticalas well as practical improvements in the performance of the algorithm for the originalproblem. We also demonstrate how already existing algorithms can be extended to solvethe bicriteria variants of the problem with constant factor approximation guarantees. Ourwork leads to practical heuristics applicable in network design.
Thesis Supervisor: David R. KargerTitle: Associate Professor of Computer Science and Engineering
Acknowledgments
Thanks to David Johnson, David Karger, and David Williamson for helpful discussions,
and to Steven Phillips for providing an initial implementation of the GW-algorithm.
Contents
1 Introduction 10
1.1 H istory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.2 Formal Problem Definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.3 Our Contribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2 Goemans-Williamson Algorithm and Its Variants 15
2.1 Linear Programming formulation . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2 Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3 Modifying the GW-algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3.1 Strong Pruning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.3.2 Unrooted growth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.3.3 Fully rootless algorithm . . . . . . . . . . . . . . . . . . . . . . . . . 29
3 Experimental results 33
3.1 Background . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.1.1 Machines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.1.2 Instances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.2 Strong Pruning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.2.1 Running times . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.2.2 Solution quality . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.3 Unrooted Growth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.4 Closeness to Optimality . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.5 Further Improvements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5
4 Bicriteria Optimization Problems
4.1 The Quota Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.1 Approximation algorithms . . . . . . . . . . . . . . . . . . . . . . .
4.2 The Budget Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.1 Trisection of a Tree . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3 Practical Heuristics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.1 Prize-multiplier approach . . . . . . . . . . . . . . . . . . . . . . .
4.3.2 Nonmonotonicity of the prize-multiplier approach . . . . . . . . . .
4.3.3 A pruning heuristic for the Quota problem . . . . . . . . . . . . .
4.3.4 Heuristics for the Budget problem . . . . . . . . . . . . . . . . . .
5 Experimental Results for the Prize-Multiplier Approach
5.1 Cost/Prize Tradeoff . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2 Nonmonotonicities in the tradeoff curves . . . . . . . . . . . . . . . . .
5.3 Comparing tradeoff curves . . . . . . . . ... . . . . . . . . . . . . . . .
5.3.1 Improvements due to interpolation . . . . . . . . . . . . . . . .
5.3.2 Improvements due to varying multiplier growth factor. . . . . .
5.3.3 GW-pruning advantage. . . . . . . . . . . . . . . . . . . . . . .
6
45
45
46
47
49
51
51
54
56
59
60
. . . 60
. . . 63
. . . 63
. . . 67
. . . 70
. . . 70
List of Figures
2-1 Snapshots of the algorithm. . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2-2 The strong pruning procedure. . . . . . . . . . . . . . . . . . . . . . . . . . 22
2-3 Meta-graph H obtained from a snapshot of the algorithm's growth phase. 26
2-4 Illustration of claim that all leaf components with the exception of the root
component are active . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2-5 The BEST-SUBTREE pruning procedure. . . . . . . . . . . . . . . . . . . . . 31
2-6 The rootless strong pruning procedure. . . . . . . . . . . . . . . . . . . . . . 31
3-1 Running times as a function of the graph size. . . . . . . . . . . . . . . . . . 37
3-2 Running times as a function of the graph size (2). . . . . . . . . . . . . . . 38
3-3 Value of GW-objective function (using original prize values) as a function of
prize m ultiplier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
4-1 Example demonstrating nonmonotonicity of the growth phase . . . . . . . . 54
4-2 Example demonstrating nonmonotonicity of the growth phase with strong
pruning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4-3 Example demonstrating nonmonotonicity of the optimal solutions to the
Quota problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4-4 Percentage of prize obtained as a function of prize multiplier. . . . . . . . . 57
5-1 Tradeoffs between cost and prize obtained by varying the prize-multiplier. . 61
5-2 Interpolating into the gaps of the prize/cost tradeoff curve. . . . . . . . . . 62
5-3 Closeup of the tradeoff curve showing nonmonotonicities. . . . . . . . . . . 64
5-4 Percentage of prize obtained as a function of prize multiplier. . . . . . . . . 65
5-5 Close up of the tradeoff curves under strong pruning and GW pruning.. 66
5-6 The step function for cost/prize tradeoff curve. . . . . . . . . . . . . . . . . 68
7
5-7 Sparse tradeoff curves. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
8
73
List of Tables
3.1 Statistics for geographic streetmap instances. . . . . . . . . . . . . . . . . . 34
3.2 Statistics for random geometric and unstructured instances. . . . . . . . . . 35
3.3 Running times (measured in secs) for the variants of the GW-algorithm and
M ST postprocessing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.4 Solution quality comparison for variants of the GW-algorithm. . . . . . . . 40
3.5 Comparison of solutions obtained by the GW-algorithm o the optimal solutions 42
5.1 Comparison of the raw and interpolated tradeoff curves and curves obtained
with different multiplier growth factors. . . . . . . . . . . . . . . . . . . . . 69
5.2 Comparison of the tradeoff curves produced with GW-pruning and strong
pruning. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
9
Chapter 1
Introduction
Suppose a telephone company wants to build at minimum possible cost a fiber-optic local
access network for providing broadband Internet connections to businesses and apartment
complexes in some geographic area. It is allowed to lay fiber only along streets and roads
and the cost to do so is dominated by labor and right-of-way charges. If the company is
required to connect each client in the area to its local access network, then we can model
this problem as a Steiner Tree problem in a graph.
In a regular Steiner tree problem, one is given an edge-weighted graph and a special
subset of vertices called terminals. The goal is to find a minimum cost subgraph (which
is a tree) that spans all of the terminals. In our network design application, the graph
will correspond to a street map of the area with the street intersections and the locations
of buildings with clients as vertices. (We can assume that building lie on the streets as a
first approximation.) The edges are then the street segments between the vertices. The
non-negative weight of an edge is equal to the cost of laying a fiber-optic cable along the
corresponding segment.
Now suppose that the company has the freedom to pick which customers it wants to
connect to its local access network. Moreover, the company's analysts have compiled some
estimates of the revenue to be obtained by connecting up each building, so that clients can
be selected according to how much the company will earn from adding them to the network.
The new goal is to build a network connecting some subset of buildings so as to maximize
the revenue while minimizing the cost of the network.
If we go back to our graph model, instead of the terminal set we now have non-negative
10
weights on all nodes. The weight associated with the vertex representing a building is the
estimate of the revenue to be obtained by connecting up that building. Vertices correspond-
ing to intersections rather than buildings have weight 0. A node's weight can be thought
of as a prize to be "collected" by including that node in a tree solution. Alternatively, it
can be thought of as a penalty to be paid for not including that node in a tree. A terminal
node from the original Steiner tree problem can be thought of as having an infinite prize or
penalty, making it necessary for it to be included in an optimal solution.
1.1 History
The Steiner Tree problem with node weights in addition to regular edge weights was first
considered by Segev [16]. He noted that when the node weights are non-negative and the root
of a solution tree is given, the problem can be turned into the directed Steiner Tree problem.
In his paper, Segev showed that another special case of the problem, called the Single Point
Weighted Steiner Tree problem, in which one is given a special node to be included in a
solution and weights on the rest of the nodes are negative, is AP-complete and developed
several heuristics for it. In Segev's model, negative weights on nodes represent profits,
while non-negative weights on edges reflect the costs incurred in obtaining or "collecting"
the profits. If we negate node weights to make them positive, then they will have to be
subtracted from the edge costs in the objective function.
The term "prize collecting" was first introduced by Balas [3] in the context of the
Traveling Salesman Problem (TSP). Balas used a complementary model for node weights -
in his problem they are non-negative and can be viewed as penalties for not including nodes
in a solution. Instead of subtracting weights of nodes in the solution from the cost of edges,
Balas added the weights of nodes not in the solution. Additionally, Balas imposed a lower
bound on the node weight of the solution.
Bienstock et al. [5] developed the first approximation algorithms both for the Prize Col-
lecting Traveling Salesman and Prize Collecting Steiner Tree problems with approximation
guarantees of 5/2 and 3, respectively. Subsequently, Goemans and Williamson improved
the approximation guarantee to just below 2 for both problems. We will describe their
result in more detail once we present the formal statement of the problems considered.
11
1.2 Formal Problem Definitions
In the Prize Collecting Steiner Tree (PCST) problem, one is given a graph G = (V, E), a
non-negative edge cost ce for each edge e E E, a non-negative vertex prize 7rv for each vertex
v C V, and a specified root vertex vo E V. We shall consider four different optimization
problems based on this scenario, the first being the one initially studied in [10, 11]:
1. The Goemans- Williamson Minimization problem:
Find a subtree T' = (V', E') of G that minimizes the cost of the edges in the tree plus
the prizes of the vertices not in the tree, i.e., that minimizes
GW(T') = Z Ce + Z v
eEE' v V'
2. The Net Worth Maximization problem:
Find a subtree T' that maximizes
NW(T')= Zrv -Zce
vEV' eEE'
3. The Quota problem:
Given a prize quota Q > 0, find a subtree T' that minimizes EeEE' Ce, subject to
ZvEV' lrv Q-
4. The Budget problem:
Given an edge budget B > 0, find a subtree T' that maximizes EvEV' 1rv, subject to
ZeEE' ce < B.
In addition, for each problem we have both the rooted variant, in which vo must be contained
in T', and the unrooted variant, in which T' can be any subtree.
Goemans and Williamson have developed an O(n 2 log n)-time primal-dual approxima-
tion algorithm for the rooted version of GW-Minimization that is guaranteed to be within a
factor of 2 - n of optimal, where n = lVi [10, 11]. (In what follows, we shall refer to this
algorithm as the GW-algorithm for short.) The perhaps more natural NW-Maximization
variant is equivalent to GW-Minimization as far as optimization is concerned, since for all
subtrees T', NW(T') + GW(T') must equal the total prize (over all vertices of V). The
12
two problems are not equivalent with respect to approximation, however: It is KP-hard to
approximate the optimum Net Worth to within any constant factor [8].
The Quota problem can be thought of as a generalization of the well-studied k-MST
problem. In the latter, given an undirected graph G = (V, E) with non-negative edge costs
and an integer k, one wishes to construct a tree of minimum cost that spans (at least)
k vertices. Note that if we have an instance of the Quota Problem in which all vertices
have prize 1, then we obtain an instance of the k-MST problem. This problem is known to
be AlP-hard. A sequence of results improved the approximation guarantee from an initial
3vX [14] to a constant factor [6]. Currently the best approximation result for the k-MST
problem is a factor-of-(2+e) algorithm [1] strongly based on Garg's factor-of-3 algorithm [9].
Interestingly, all three constant-approximation algorithms depend in a crucial way on the
GW-algorithm mentioned above, as we shall explain in more detail below. We know of no
previous approximation results for the Budget problem, rooted or unrooted.
1.3 Our Contribution
In this thesis we consider variants on the Prize Collecting Steiner Tree problem and the
primal-dual 2-approximation algorithm devised by Goemans and Williamson. This algo-
rithm first grows a feasible tree solution and then prunes it to reduce the cost in order to
meet the approximation guarantee. Our goal is to test how well the algorithm performs
in practice on the problem for which it was originally developed and to see how it can be
adapted to solve the related variants. To that end we provide both theoretical guarantees
and experimental data on the performance of the algorithm and several heuristics derived
from it.
In considering the original problem, GW-minimization, we introduce an improved prun-
ing rule for the algorithm that is slightly faster and provides solutions that are provably at
least as good and typically significantly better. We also show that modifying the growth
phase of the Goemans-Williamson algorithm to make it independent of the choice of root
vertex does not significantly affect the algorithm's worst-case guarantee or behavior in prac-
tice. The resulting algorithm can be further modified so that, without an increase in running
time, it becomes a 2-approximation algorithm for finding the best subtree over all choices
of root.
13
To test our modifications we implemented both versions of the algorithm, with the orig-
inal and modified pruning rules. We present experimental data comparing the performance
of the two versions on a selection of real-world instances whose underlying graphs are county
street maps and on a series of randomly generated instances. We also test experimentally
the modification to the growth phase of the algorithm. The resulting data is then used for a
limited comparison to the optimal solutions, obtained with a branch-and-cut optimization
algorithm for the unrooted version of the problem.
In the second part of the thesis, we consider Quota and Budget versions of the problem.
We observe how constant-factor approximation algorithms for the k-MST problem can be
extended to it. We also show how a (5 + e)-approximation algorithm for the (unrooted)
budget problem can be derived from Garg's 3-approximation algorithm for the k-MST.
None of these algorithms are likely to be used in practice, but we show how the general
approach behind them (which involves performing multiple runs of the Goemans-Williamson
algorithm using an increasing sequence of prize-multipliers) can be incorporated into a
practical heuristic. We also uncover some surprising properties of the cost/prize tradeoff
curves generated (and used) by this approach.
* This thesis is based on the joint work with David S. Johnson and Steven Phillips. A
preliminary version appeared in SODA 2000 [12].
14
Chapter 2
Goemans-Williamson Algorithm
and Its Variants
2.1 Linear Programming formulation
Our work is heavily based on the primal-dual approximation algorithm of Goemans and
Williamson for the rooted GW-minimization problem. In this section we will present the
linear programming formulation used by the authors and outline the main points of the
algorithm.
Recall that the goal is to construct a subtree which minimizes the cost of its edges in it
plus the total prize value of the vertices not in the tree. A prespecified root vertex r has
to be included in the tree. To model this problem as an integer program, Goemans and
Williamson use the following integer variables:
1 if e is in the tree
0 otherwise
for each edge e E E, and
{ 1 if N is the set of all vertices not spanned by the tree
0 otherwise
for each subset of vertices N C V not containing the root. The following constraint ensures
15
that ZN is non-zero for at most one set N
E zN <lNCV-r
If a subset of vertices S not containing the root intersects the tree solution, then its cut
must contain at least one edge of the tree. Otherwise, this subset is contained within the
set of all vertices not spanned by the tree. This condition can be expressed by the following
constraint.
S Xe+5ZN 1eEt(S) NDS
Relaxing the integrality constraints on variables and dropping the constraint EN ZN < 1
which does not affect the optimal solution (it is satisfied automatically by an optimal solu-
tion because of the second term of the objective function), we obtain the following linear
programming relaxation:
E CeXe + E ZN ErieEE NCV-r iEN
E Xe+(EZN 1
eE6(S) NDS
Xe,ZN 0
SCV-r
NCV-r.
The dual of this LP has a non-negative variable ys for each subset of vertices S C V - r:
Max
subject to:
E YSS:rS
Z YS CeS:eE6(S)
EyS riSCN iEN
yS > 0
eEE
NCV-r
SCV-r.
16
Min
subject to:
2.2 Algorithm
Goemans-Williamson's algorithm for the PCST problem is based on a primal-dual schema
and consists of two phases. First a feasible dual solution is constructed directly and a corre-
sponding integral primal solution satisfying the primal complementary slackness conditions
is found. These conditions correspond to the primal variables and dual constraints:
Xe ce - E Ys = 0
S:eEJ(S)
ZN 7i - E YS = 0E N SCN )
The integral primal solution thus obtained induces a forest F and a set of vertices not in
the forest X. The primal complementary slackness conditions imply the following facts:
" Each edge in the forest is fully paid for by the dual variables, i.e. for all e E F, Xe > 0
and so
ce= YSS:eES(S)
" The penalty on vertices not in the forest is also fully paid for by the dual variables,
i.e. zX > 0, so
Z ri ZYSiEX SCX
In the second stage, a subtree is extracted from the root-containing component of the
forest by deleting some edges.
Growth Phase
The algorithm starts out with an initial dual feasible solution, in which all variables ys are
set to zero. It then attempts to increase the dual variables ys as much as possible without
17
violating the following two types of packing constraints:
Z YS ce (2.1)S:eE6(S)
E yS 'ri (2.2)SCN iEN
In the growth phase, the algorithm maintains a set of components partitioned into active
and inactive. Each component C has a non-negative surplus s(C) associated with it. A
component is active iff it has a positive surplus and does not contain the root. Initially,
each vertex is its own component with the surplus equal to its prize value.
At each step, the algorithm uniformly raises dual variables yc corresponding to active
components C, while decreasing their corresponding surpluses s(C) to pay for the increases,
until one of the 2 events occurs:
1. Inequality (2.1) becomes tight for some edge e = (u, v) spanning two different com-
ponents. The algorithm merges those two components into a new one, assigning it
the sum of their current (remaining) surpluses. If one of the merged components con-
tained the root, then the new component is declared inactive regardless of how much
surplus it still has.
2. Inequality (2.2) gets satisfied with equality for some set S; moreover this set must be a
currently growing (active) component, since the only dual variables that are changing
at any moment are the ones corresponding to active components. This event occurs
when an active component's surplus gets reduced to zero. The algorithm deactivates
component S, since it cannot pay for any new edges. Additionally, all unlabeled
vertices of S get labeled with label S.
At any point of the algorithm the "tight" edges (from Inequality (2.1)) form a tree inside
each component. The growth phase terminates when there are no more active components
left: either all vertices are in the root component or all non-root components' surpluses
have been reduced to zero.
Several snapshots of the growth phase are shown in Figure 2-1. Snapshots (a) and (b)
are one iteration apart, while the third snapshot (c) shows the forest F at the end of the
growth phase. The cost of an edge is the Euclidean distance between its endpoints.
18
root ~
/
(a)
root
*
/
(b)
root'
I- - -
I0(c)
Figure 2-1: Snapshots of the algorithm (a) after 2 iterations (b) after 3 iterations (c) at theend of the growth phase. Dashed lines represent inactive components.
19
1---,
Pruning Phase
In this phase the algorithm deletes as many edges from F as possible, while ensuring that
the following 2 properties hold:
1. every unlabelled vertex is connected to the root r (the algorithm has not paid the
penalty for such a vertex);
2. if vertex v with label C is connected to r, so is every vertex with label C' D C.
We shall refer to this original procedure as "GW-pruning." In addition to removing all com-
ponents not containing the root, it deletes some edges and vertices from the root-containing
component to bring down the value of the objective function. In particular, leaf subtrees
corresponding to inactive components (which later became part of active components) get
removed.
The growth phase can be implemented to run in O(n 2 log n) by maintaining a priority
queue of times at which edges are expected to become tight and components are expected to
become deactivated. The pruning phase can be implemented in O(n2 ) time by performing
at most n depth-first searches to locate all the unlabeled vertices and other vertices that
have to be kept.
The following result is proved by Goemans and Williamson in [10]:
Theorem 2.1. The algorithm presented above produces a tree T containing a prespecified
root vertex rand a feasible dual solution ys such that
SCe+ E ; (2- yseEE(T) i V(T) SCV
Hence, the algorithm is a 2 - n1-approximation algorithm for the Prize Collecting Steiner
Tree problem.
2.3 Modifying the GW-algorithm
In this section we will introduce several variants of the GW-algorithm obtained by altering
the pruning phase and/or the growth phase. First we will prove that replacing GW-pruning
by a simple greedy pruning heuristic results in solutions at least as good as the ones produced
by the original algorithm. Next we show that making the growth phase independent of the
20
choice of a root vertex results in only a slight degradation of the algorithm's worst-case
guarantee. However, this modification transforms the GW-algorithm, originally designed
to solve the rooted problem, into a 2-approximation algorithm for finding the best subtree
over all choices of the root, without an increase in asymptotic running time.
2.3.1 Strong Pruning
While the intricate GW-pruning procedure is necessary to prove the approximation guar-
antee of 2 - ,- , it is not the most efficient method for pruning a tree. It often produces
suboptimal subtrees of the starting tree with respect to GW objective function.
Definition 2.2. The net worth of a component C, nw(C), is the total prize contained in
C minus the cost of edges inside C, i.e. nw(C) = EiEc 2 i - EECC ce.
Assuming (as we do) that prizes are non-negative, a tree consisting of just the root
vertex has net worth of at least 0. Thus, if we want to maximize the net worth NW of a
tree returned, it makes sense to only return solutions with non-negative net worth value.
This doesn't hold for the solutions generated by GW-pruning, as it is capable of producing
solutions with negative NW. Recall that the NW value of a tree and its GW objective
function value add up to the total amount of prize in the tree (which is constant for a
given instance). Thus, optimizing NW over subtrees of a given tree also optimizes the GW
objective function, and vice versa. Since GW-pruning performs suboptimally with respect
to the NW objective function, it does so also with respect to the GW objective function.
Our first observation is that there is a straightforward greedy heuristic that maximizes
the NW value of a subtree produced by pruning. This heuristic, which we call strong
pruning, provably dominates GW-pruning and can thus be substituted for it without any
loss in the worst-case guarantees for the GW-algorithm.
Suppose we are given a tree T of G with root r, which has to be pruned. Let us view
all the edges of T as directed away from the root. Strong pruning can be defined by the
recursive program shown in Figure 2-2, initially applied to the root of the tree r.
It is easy to see that strong pruning can be performed in 0(n) time (versus 0(n2 ) in
the worst case for GW-pruning). Moreover, since it does not require any knowledge of what
went on during the growth phase, none of the detailed labeling and record-keeping required
for GW-pruning need be performed during that phase, which simplifies the programming
21
STRONG-PRUNE(V)
1 T, <- {v}2 nw(T ) +- ir(v)3 for each u = child of v in T4 do Tu +- STRONG-PRUNE(U)
5 e +- edge (v, u)6 if nw(Tu) > ce7 then T, +- T, U Tu U {e}8 nw(T,) +- nw(T,) + nw(T,) - Ce9 else delete e and subtree Tu
10 return Tv
Figure 2-2: The strong pruning procedure.
task.
Definition 2.3. Let us denote by s(C) the number of vertices in a component C. Define
NW-optimal subtree of a tree to be a subtree T' with the lexicographically largest pair
(w(T'), s(T')).
By a subtree rooted at a vertex u of a rooted tree T we denote a subtree of T which is
allowed to contain only u and 0 or more of its successors.
Theorem 2.4. Given a rooted tree T containing vertex v, the recursive procedure
STRONG-PRUNE(v) finds a NW-optimal subtree rooted at vertex v.
Proof. We will prove our claim by induction on the height of the original tree T. Base case:
vertex v is a leaf. STRONG-PRUNE(v) returns a subtree T, consisting of just {v}. The claim
holds trivially since an optimal subtree rooted at a leaf vertex is that vertex itself.
Consider some vertex v that is not a leaf. Let us assume that STRONG-PRUNING has
correctly returned the best subtrees rooted at children of v. We will now show that the
subtree Tv returned by STRONG-PRUNING(v) is an optimal subtree rooted at v.
Let u be one of the children of v. Let T denote the best subtree rooted at u. Consider
the net worth of Tu versus the cost of the edge e.
* Case 1: w(Tu) < ce
In this case STRONG-PRUNING does not add edge e, so that the subtree rooted at v
will not contain e. We claim that in this case, the optimal subtree rooted at v will not
contain e either. Consider any subtree T' rooted at v that contains edge e. The net
22
worth of the subtree obtained by removing e from T' is at least w(T') - (w(T) - Ce) >
w(T'), since w(Ts) - ce < 0. The net worth of T' can be increased by removing edge
e. Hence, T' cannot be optimal.
" Case 2: w(Ts) > Ce
In this case STRONG-PRUNING adds edge e together with T, so that the subtree
rooted at v will contain e. We claim, similarly, that the optimal subtree rooted at v
must contain e. Once again consider any subtree T' rooted at v that does not contain
edge e. The net worth of the subtree obtained by adding e together with T to T'
is equal to w(T') + (w(Ts) - Ce) > w(T'), since w(Ts) - Ce > 0. The net worth of
T' U e U Tu is greater than the net worth of T'. Hence, T' cannot be optimal.
" Case 3: w(Tu) = ce
In this case, including edge e and Tu does not decrease the net worth of a subtree
without them. However, adding this edge and T. to a subtree increases its size. Hence,
the optimal subtree rooted at v must contain e.
Thus, T, must be the optimal subtree of T rooted at v. E
Notice that in the special case when v is the root of T, we obtain a NW-optimal subtree
of T containing the root.
Corollary 2.5. Let T be any subtree of G rooted at r, let T' be a subtree of T obtained from
T via G W-pruning, and let Tsp be the tree obtained from T by running STRONG-PRUNING(r).
Then GW(Tsp) < GW(T').
Thus, strong pruning is provably superior to GW-pruning.
2.3.2 Unrooted growth
So far we have been concentrating on the second phase of the algorithm in which postpro-
cessing of the solution takes place. Let us now turn our attention to the first phase, in
which the initial primal feasible solution is obtained. Recall that the GW-algorithm treats
the root vertex in a special way during the growth phase. In particular, the component
that contains the root, which we shall call the "root" component for simplicity, is always
kept inactive, regardless of how much surplus it has.
23
What if we allow for the root component to be active and grow just like any other
component while it has positive surplus? The root component would get deactivated only
when it no longer has positive surplus, and it could become active again when joined by
another component with sufficient amount of surplus. Let us call this modified procedure
an unrooted growth phase, to reflect the fact that the root vertex and root component are
no longer treated differently from the rest.
Let us consider an algorithm UGW that we obtain by using the unrooted growth phase,
and then performing GW-pruning on the root component. Notice that this algorithm and
the original GW-algorithm might not produce the same end result when run on the same
input. If some component does not have enough surplus to join the root component by itself,
the original GW-algorithm will deactivate such component and label all of its vertices. The
unrooted growth algorithm, on the other hand, might allow for this component to get
connected to the root, given that the root component has sufficient amount of surplus.
Thus, the unrooted growth algorithm will have to keep this component since its vertices
will never be labeled, while the original GW-algorithm might prune the component away.
Notice that a more aggressive strong pruning that evaluates each component's worth to
the final tree, might work better for the unrooted growth algorithm. Nonetheless, making
a slight modification to the original Goemans-Williamson approximation guarantee proof
to take into account the existence of one additional active component we can prove the
following guarantee:
Theorem 2.6. The UGW algorithm consisting of unrooted growth followed by (rooted)
GW-pruning is a (2 - -)-approximation algorithm for the rooted Prize Collecting Steiner
Tree problem.
Proof. Let F' be the set of edges left after the pruning phase of the algorithm, and X be
the set of vertices not spanned by the edges of F'. It is easy to see that (F', X) is a feasible
solution. By the construction, the set of edges produced by the algorithm before the pruning
phase is a forest. After the pruning phase, no nontrivial component not containing the root
r is left and the component containing r is a tree.
To show that the altered algorithm is a (2 - -)-approximation algorithm, we will prove
24
that the following holds:
Ce + Elri (2 - ) y Y (2 - )ZPCI P, (2-3)eEF' iEX n SCV
where ZC is the value of the optimal solution to the prize-collecting Steiner tree problem.
By the construction, each vertex i E X lies in some deactivated component. If i E C,
where C is some deactivated component, then by pruning rule, all of the vertices of C are
in X. Hence, we can partition X into disjoint deactivated components C1,... Ck. Since
the algorithm deactivates a component when the sum of the corresponding dual variables
reaches the total amount of prize "possessed" by the component, it follows that for each
C,, EsCC Ys = EiEC ri. Additionally, by construction, ce = ZS:eE3(S) ys for any edge
e E F'. Thus, we need to prove that
s ys+ Z ys (2 - ) ys,eEF' S:eE3(S) j ScCj ScV
or, exchanging the summations in the first term of the left-hand side, that
YsIF'f n (S)+ ys 5 (2 - ) ys. (2.4)SCV j SCCj SCV
This inequality can be proven by induction on the main loop of the algorithm. The base
case is trivial since ys = 0 for all S C V initially. For the induction hypothesis suppose that
the Inequality (2.4) holds at the beginning of some iteration for the current values of dual
variables. Let C denote the set of currently active components. Construct a meta-graph
H with components (both active and inactive) as nodes and the edges e E ((C) n F') for
active C as arcs. Discard all isolated inactive nodes. Notice that the arc set of H consists
of the edges yet to be added (and kept later on) by the algorithm. Let Na denote the set
of nodes corresponding to active components, Ni the set of nodes corresponding to inactive
components, Np the set of active nodes corresponding to active components contained in
C, for some j, and d, the degree of a node v in H. Note that d, = 6(C) nl F', where C is
the component corresponding to v.
25
components
active
inactive
active,later deactivated
root
F'
F-F'
Figure 2-3: Meta-graph H obtained from a snapshot of the algorithm's growth phase. Ovalscorrespond to nodes of H, thickened edges correspond to arcs of H.
Claim 2.7.
S dv +|JNp|< 2 - |N.1VENa
We will prove Claim 2.7 later. Let us now show that it suffices to prove our induction
claim.
During the current iteration, each dual variable yc corresponding to an active component
C E C increases by a certain e. All other dual variables corresponding to any set S that is
not an active component, stay the same. Hence, the increase in the right-hand side of the
Inequality (2.4) is
2--zE 2 - ) INa|ICEC
The left-hand side of the Inequality (2.4) increases by
ZeIF'n(c)+Z Z:CEC j CCCj,CEC
E= E F'n6(C)j+ {C E C: 3j C CC\CEC
Noticing that d, = 16(C) n F'j, where C is the component corresponding to v, and each
active component C s.t. 3j C C Cj corresponds to a vertex in Np, we can rewrite the left-
hand side increase as e(EVEN. dv + INpl). By Claim 2.7, the increase in the left-hand side is
bounded by the increase in the right-hand side, and so the induction proof is complete. E
26
edges
0---@
Proof of Claim 2.7. We would like to show that the following holds
Z d +Np| 2- ) INa|VENa
in a meta-graph H induced by active and inactive components during any iteration. We
will actually prove a slightly stronger inequality
E d 2 - )(INa| - Np) (2.5)vENa
from which our claim follows. The basic intuition behind the proof is that the average
degree of a node in a forest spanning n nodes is at most 2(n-1) = 2 - . We will use somen nother properties of the meta-graph H to obtain additional bounds on the degrees of nodes
in meta-graph H.
Recall that Na is the set of nodes corresponding to active components, Ni is the set
of nodes corresponding to inactive components, and Np is the subset of Na corresponding
to active components contained in X, the set of vertices not spanned by solution F'. An
active component in the latter category must have eventually been deactivated and pruned
away, so there are no edges connecting such a component to the root in F'. Hence, dv = 0
for Vv E Np.
We can rewrite
5 dv = 5 + dvvENa vENa-Np vENp
= S dv-5 dv.vE(N-Np)UNi vENi
Since H is a forest, the number of arcs of H is no more than the number of nodes of H
(with non-zero degrees) minus 1. Hence,
E dv 2(I(Na - Np) U Nil - 1) = 2(|Na - INpI +INi| - 1)vE(Na-Np)UNj
Next we would like to get a lower bound on EvEN dv, in order to bound EvEN dv.
To do this, we show that at most one node corresponding to an inactive component can
27
root
e ,
CV
active
inactive
Figure 2-4: Illustrationcomponent are active
of claim that all leaf components with the exception of the root
be a leaf. More precisely, we claim that if v E Ni is a leaf, then its corresponding inactive
component Cv must be the root component. We prove this by contradiction. Suppose that
r C,. Since C is inactive, it must have been deactivated at a certain point and all of its
vertices have been labeled. Let e be an edge incident on v in H. Since v is a leaf, no vertex
in C, can lie on a path from the root to any (unlabeled) vertex that is required by the
algorithm to stay connected to the root. By the GW-pruning rule we should have thrown
edge e away, i.e. e 0 F' - contradiction. Therefore, a leaf in H corresponds either to an
active component or an inactive component that contains the root.
Hence, d, > 2 for all v E Ni except for at most one node. This yields the desired lower
bound:
dv ; 2(1Nil - 1) + 1 =2Nil - 1VENi
Then
ZdENVENa
= Z dv -Z dvVE(N-Np)UNi VENi
2(|Naj - |Nj + |Nji - 1) - (2INI| - 1)
= 2(|NaI - INpI) - 1
( 2 - (INal -jN,|)Nal
( 2-- (|Na| -|JNp|)n
28
as desired, since the number of active components INal n.
REMARK: We can rearrange terms in Inequality (2.5) as follows:
d, + (2 - -)|Np| :! (2 - 1)|NajVENa
1racing back the values of do, INal, and |NpI we observe that this corresponds to the
strengthening of the original approximation inequality (2.3) to
Z Ce + (2 - ) ri (2 - ) S ys (2.6)eEF' iEX SCV
The UGW-algorithm is designed to solve the rooted version of the problem. The solution
that it produces is a function of the root vertex specified. However, notice that a forest F
produced by the unrooted growth phase is the same for any choice of the root. It might
thus appear surprising at first that a procedure whose main part doesn't depend on the
choice of root yields a solution which is within a factor of 2 from an optimal solution for
an arbitrary root. The explanation lies in the fact that the same tree can be optimal for
several different choices of the root. Given an optimal tree T for a specific root r, if r has
sufficient amount of prize, the same tree is optimal for neighbors of r in T and possibly for
some other nodes in T,.
2.3.3 Fully rootless algorithm
So far we have considered only the rooted version of the problem. Notice that the GW-
algorithm constructs a solution around a prespecified root vertex. We can always solve
the rootless version of the problem, i.e. the problem of finding the best subtree of a given
graph without any restrictions on which vertices have to be included, in O(n3 log n) time by
running the algorithm with every vertex as a root and outputting a tree with the smallest
GW value. This method is guaranteed to produce a solution within a factor of (2 - n' 1)
of optimal. However, this seems to be wasteful, since for a number of choices of root
vertices the resulting tree solutions are identical. If we were willing to settle for (2 - )-
approximation, we could use the unrooted growth phase to obtain a forest F and then
perform GW-pruning of F with every possible choice of a root. This algorithm would run
29
in 0(n2 log n) +n-O(n2 ) = 0(n3 ). We can reduce the overall running time to 0(n2 log n) +n-
0(n) = 0(n2 log n) by using strong pruning instead of GW-pruning for every root (without
any loss in the approximation guarantee).
We can further simplify the algorithm, and pruning phase in particular, by eliminating
altogether the notion of the root as a special vertex, when solving the rootless variant of
the problem. Our modified algorithm will be implicitly solving the problem for all possible
choices of root simultaneously, while obtaining exactly the same result as the algorithm that
picks the best tree obtained by applying rooted strong pruning for all choices of a root on
a forest produced by unrooted growth phase.
In the procedure STRONG-PRUNE(r) presented above, the root vertex plays a crucial
role: we are pruning non-root vertices off in order to increase the NW value of the subtree
containing the root. Recall that an edge is kept only if including it and the subtree hanging
off the endpoint farthest from the root doesn't decrease the NW of the rest of the tree.
Once we eliminate the notion of the root, there is no central vertex from which to prune.
Moreover, now when we consider an edge (u, v), including it might be profitable for one of
the subtrees and unprofitable for the other. The way to break the symmetry is to give more
"weight" to the subtree with larger net worth, since after all we are trying to maximize
NW. But we don't want to delete any subtrees, since we don't know which one of them will
turn out to have the largest net worth. Instead, we can keep track of the best tree seen so
far, and update it if necessary each time a new tree is constructed.
Procedure BEST-SUBTREE given in Figure 2-5 is very similar to the STRONG-PRUNE.
In fact, the two routines return exactly the same tree when applied at the same vertex.
However, in the latter, when an edge doesn't get included, no subtrees are deleted. This
allows to keep track of the best subtree seen so far kept in in a global variable T'. Before
returning a subtree it is compared against the subtree T', updating T' if necessary.
To obtain the best subtree of a forest F, procedure GLOBAL-STRONG-PRUNE given
in Figure 2-6 performs rootless strong pruning on every component of the forest by picking
an arbitrary starting vertex from each and calling BEST-SUBTREE from it. The latter keeps
track of the best subtree seen so far as it goes along. Once again, among all subtrees with
maximum net worth we want to pick a subtree that spans the maximum number of vertices.
Next we show that the tree produced by GLOBAL-STRONG-PRUNE(F) is no worse than
a tree we would obtain if we were to run strong pruning on forest F with each vertex as a
30
BEST-SUBTREE(V)
1 TV +- {v}2 nw(Tv) +- 7r(v)3 s(T,) +- 14 for each u = ch5 do Tu +-6 e +- e(7 if nw(8 the9
1011 if nw(T) ;> nw12 then if nw(13 the141516 return T,
ild of v in TBEST-SUBTREE(U)
dge (v,u)
Tu) > Cen T, +- Tv U T, u {e}
nw(Tv) <- nw(Tv) + nw(Tu) - ces(T,) +- s(Tv) + 1
(TO)Tv) > nw(TO) or s(T,) > s(TO)ri TO +- T,
nw(TO) +- nw(Tv)s(TO) +- s(Tv))
Figure 2-5: The BEST-SUBTREE pruning procedure.
GLOBAL-STRONG-PRUNE(F)1 TO +- 02 nw(T) +--oo3 s(tO) +- -14 for each T = component of F5 do r <- arbitrary vertex of T
6 BEST-SUBTREE(r)
7 return To
Figure 2-6: The rootless strong pruning procedure.
root and then pick the best tree found. The main difference would be that we would have
spent 0(n2 ) versus only 0(n) time taken by GLOBAL-STRONG-PRUNE.
Theorem 2.8. Given a forest F, the generalized strong pruning procedure
GLOBAL-STRONG-PRUNE(F) returns a NW-optimal subtree of F.
Proof. Let T* be an optimal subtree of F, C be the connected component containing T*,
and r be the previously picked root of C. Let r, be the vertex of T* closest to the root r (it
might be r itself). We can think of T* as being "suspended" from r. At a certain step the
BEST-SUBTREE has found Tro, the optimal subtree of C rooted at r". Since T* also fits the
definition of a subtree of C rooted at ro, (w(T*), s(T*)) j (w(Tro), s(Tro)). However, T* is
an optimal subtree of C, so w(T*) ;> w(Tro). Hence, w(T*) = w(Tro) and s(T*) = s(Tro).
31
Thus, when T,, was found, it must have been the best tree seen so far. The final tree TO
must be at least as good by construction, so To is an optimal subtree of F. El
As discussed earlier, we can obtain a(2 - -)-approximate solution to the unrooted Prize
Collecting Steiner Tree problem by performing an unrooted growth phase and then doing
strong pruning for every possible choice of the root. The above theorem implies that a
solution obtained by applying (once) GLOBAL-STRONG-PRUNE we obtain a solution at least
as good. From the viewpoint of implementation, the latter algorithm is more advantageous,
since the pruning phase is performed only once.
Corollary 2.9. The UUS algorithm, consisting of the unrooted growth phase followed by
the generalized strong pruning, is a (2 - -)-approximation algorithm for the unrooted Prize
Collecting Steiner Tree problem, that runs in O(n 2 log n) time.
32
Chapter 3
Experimental results
In this chapter we present experimental data comparing the performance of several variants
of the GW-algorithm for the Prize Collecting Steiner Tree problem discussed earlier. We
start by describing experimental background, including the types of instances used in our
experiments. We then proceed to discuss the results.
3.1 Background
3.1.1 Machines
All our experiments were run on single 194 or 196 Mhz MIPS R10000 processors contained
in shared-memory multiprocessor SGI Power Challenge computers with 2 or 6 gigabytes of
random access memory, more than enough for our experiments to fit in main memory. Data
and instruction cache sizes were 32 kilobytes. This is sufficiently small that our running
times were likely affected by (not-easily-quantifiable) caching effects. (Fortunately, highly
detailed conclusions about running time are not needed here.) The operating system was
IRIX 6.2, and the programs were written in C and compiled using the SGI-supplied compiler.
3.1.2 Instances
We report on three classes of instances. The first consists of instances whose graphs were
derived from the street maps of 12 U.S. counties of varying demographic characteristics,
ranging from Silicon Valley to Chicago to suburbs of Washington, D.C., and from 14,000
to 76,000 vertices. Edge costs are approximately the Euclidean distance in miles, and
33
Streetmap Graphs Ave. %% Ave Vertices
County Vertices Edges Prizes P/C in TreeCook IL 76,115 128,375 8.6 7.6 24.6
Dallas TX 47,082 75,593 9.0 4.0 18.4Wayne MI 41,433 69,917 9.7 3.0 19.3
King WA 43,902 67,344 14.1 1.1 10.1Suffolk NY 43,092 66,645 10.5 2.4 15.0Nassau NY 32,067 51,676 5.7 10.3 25.8
Oakland MI 28,305 43,223 15.4 1.8 15.9Franklin OH 21,765 34,216 12.8 2.8 20.1
Duval FL 20,995 32,890 13.6 2.3 16.4Jefferson KY 15,191 23,853 12.9 1.9 12.4
Montgomery MD 14,918 22,518 15.5 4.3 27.8San Mateo CA 14,429 22,442 13.7 4.2 21.5
Table 3.1: Statistics for our testbed of geographic instances. The "% Prizes" column givesthe percentage of vertices with nonzero prizes and the "Ave P/C" column gives the ratioof the average nonzero prize to the average edge cost. The "Ave. % Vertices in Tree"column gives the average percentage of vertices included in the tree generated using theGW-algorithm with rooted strong pruning.
prize vertices (ones with nonzero prize) and their associated prizes are placed so as to
reflect demographics. Basic statistics for these instances, including county name, numbers
of vertices and edges, percent of vertices with nonzero prize, and the ratio of the average
nonzero prize to the average edge cost, are reported in Table 3.1.
The second class of instances are random geometric instances designed to have a local
structure somewhat similar to that of our street map instances. Vertices correspond to
random points in the unit squaie. There is an edge between two vertices if their distance
is no more than 1.6/,/, and the cost of an edge is the Euclidean distance between the
two points. A vertex received a nonzero prize with probability 0.15, and the prize values
were chosen uniformly between 0 and 3/#/. These dependencies on n were chosen so that
the resulting graphs would have roughly constant expected average degree and (average
non-zero prize)/(average edge cost) ratios, as can be seen from the statistics presented in
Table 3.2. Values of n were chosen going from 100 to 25,600 by factors of 4, and several
examples were produced for each value of n.
Our final class was also designed to have constant expected degree and prize/cost ratio,
but beyond that was unstructured. Two vertices have an edge between them with probabil-
ity 6/n, a vertex has nonzero prize with probability 1/4, and both edge lengths and vertex
34
Random Graphs Ave %# Ave % Ave Ave Vertices
Type Vertices Inst. Prizes Degree P/C in TreeGeometric 100 11 12.6 6.9 1.32 3.7
400 11 14.9 7.5 1.49 5.51,600 11 14.7 7.8 1.39 7.56,400 5 15.2 7.9 1.43 10.5
25,600 5 15.2 8.0 1.41 10.5Unstructured 100 5 29.4 6.3 .99 35.3
400 5 26.4 5.9 .98 31.81,600 5 24.9 6.0 .99 31.26,400 5 25.2 6.0 1.02 31.8
25,600 1 25.4 6.0 1.00 31.3
Table 3.2: Statistics for our testbed of random instances. The "% Prizes" column gives thepercentage of vertices with nonzero prizes and the "Ave P/C" column gives the ratio of theaverage nonzero prize to the average edge cost. The "Ave. % Vertices in Tree" column givesthe average percentage of vertices included in the tree generated using the GW-algorithmwith rooted strong pruning.
prizes are chosen uniformly between 0 and 1. Details are once more included in Table 3.2.
The two random classes were chosen to share some of the properties of our proposed
application (bounded vertex degree, and prize/cost ratios) while potentially providing in-
sight into the dependence of results on n in different parts of the space of possible instances.
Other distributions might also provide insight, although we note that it takes some thought
to design classes for which the GW-algorithm does not degenerate to claiming either all the
prize or only the prize at the root (which comes for free).
3.2 Strong Pruning
In Section 2.3.1 we have demonstrated that strong pruning, a greedy heuristic that maxi-
mizes the net worth of a subtree, theoretically dominates GW-pruning. However, we wanted
to test if the same would hold in practice, since after all, our guarantees are for the worst
case only. We also wanted to see if strong pruning would be advantageous with respect to
the running time, since it can be implemented to run in linear time versus quadratic time for
GW-pruning in the worst case. Experimental results for strong pruning are summarized in
Tables 3.3 and 3.4, with running times given in Table 3.3 and solution quality data given in
Table 3.4. These tables also contain data on some additional ways to postprocess solutions
(to be discussed in detail later).
35
3.2.1 Running times
Streetmap Graphs Rooted GW-algorithm Rootless algorithm MSTOriginal w/ Strong Pruning Unrooted Strong
County growth pruning growth pruning growth pruningCook IL 325.22 0.64 324.44 0.40 589.23 1.26 0.46
Dallas TX 102.69 0.39 104.25 0.25 152.35 0.81 0.23Wayne MI 84.54 0.33 84.33 0.22 128.89 0.68 0.20
King WA 28.05 0.27 27.30 0.14 41.59 1.43 0.15Suffolk NY 60.21 0.33 60.41 0.21 89.24 0.83 0.18Nassau NY 48.95 0.27 48.46 0.18 72.71 0.54 0.18
Oakland MI 26.91 0.21 25.15 0.13 41.34 0.47 0.12Franklin OH 13.36 0.16 12.75 0.11 19.07 0.35 0.10
Duval FL 10.06 0.15 10.33 0.09 18.34 0.35 0.09Jefferson KY 6.37 0.10 6.61 0.07 10.98 0.24 0.05
Montgomery MD 5.69 0.10 5.21 0.07 8.99 0.22 0.08San Mateo CA 6.35 0.10 5.61 0.06 8.13 0.22 0.06
Random Graphs Rooted GW-algorithm Rootless algorithm MSTOriginal w/ Strong Pruning Unrooted Strong
Type Vertices growth pruning growth pruning growth pruningGeometric 100 0.00 0.00 0.00 0.00 0.01 0.00 0.00
400 0.03 0.00 0.03 0.00 0.03 0.00 0.001600 0.24 0.01 0.23 0.01 0.31 0.02 0.00
6,400 2.84 0.07 2.84 0.05 4.90 0.15 0.0425,600 82.30 0.33 80.42 0.22 169.07 0.71 0.17
Un- 100 0.01 0.00 0.01 0.00 0.01 0.00 0.00structured 400 0.08 0.00 0.08 0.00 0.11 0.01 0.00
1,600 1.16 0.01 1.15 0.00 1.79 0.02 0.016,400 32.21 0.06 32.89 0.04 51.06 0.16 0.05
25,600 1339.99 0.37 1350.77 0.25 1775.78 0.77 0.34
Table 3.3: Running times (measured inMST postprocessing.
secs) for the variants of the GW-algorithm and
Examining just the running times of pruning phases provided in Table 3.3, it is clear
that strong pruning is about 35% faster than GW-pruning. However, the difference in
overall running time between implementations using GW-pruning and strong pruning is
insignificant, even though strong pruning is asymptotically better in the worst case. This
is because the running time is dominated by the O(n 2 log n) growth phase. Notice also,
that although GW-pruning has worst-case time 0(n2 ), it appears to be taking linear time
in practice.
In Figure 3-1 we plot using a logarithmic scale the running time of the original rooted
GW-algorithm as a function of the number of nodes for both classes of random graphs. The
36
4 Random Graphs10
10
102 +
3 10
E+0) 0 0
10 -1-
10
10 -
102 10 3 10 4 10 5
number of nodes, n
Figure 3-1: Running times as a function of the graph size for random geometric ("+"symbols) and unstructured ("o"symbols) graphs.
straight lines fitted to the data points for geometric and unstructured instances have slopes
1.59 and 2.00 respectively. Thus, at least for the random unstructured class of instances, the
measured running times appear to be trending towards the O(n 2 log n) worst-case bound,
although it is difficult to disentangle cache-miss effects from algorithmic ones on the larger
instances, and even our largest instances take less than a half-hour on our relatively slow (by
today's standards) machine. This is presumably due to the fact that those instances have
higher average percentage of vertices with nonzero prizes (about twice as much as geometric
instances), allowing for more component merges. The latter leads to more iterations of the
algorithm. Not surprisingly, the average percentage of vertices included in a solution tree
for the unstructured instances is also much higher than for the geometric ones (see last
column of Table 3.2.
A similar running time growth appears also to occur for the street map instances, al-
though here the picture is less clear. Given the wide variation in geography and population
density among the counties covered, counties with roughly the same numbers of vertices
and edges can yield widely different running times. For instance, King, Suffolk, and Wayne
37
Streetmap Graphs
102
E
10
10
10 10
number of nodes, n
Figure 3-2: Running times as a function of the graph size for streetmap graphs. Fitted line
has slope = 2.18
Counties all have graphs with around 43,000 vertices and 67,000 edges, but the running
times for the last two are roughly 2 and 3 times as long as that for the first. This is presum-
ably because of the differing percentage of prize vertices among the three graphs and the
different ratios of average prize to average edge cost, which lead to significantly different
sizes for the output trees.
We suspect that, although it was not needed for the experiments reported here, a sig-
nificant improvement in running time could be obtained by more careful engineering of
the data structures used for the growth phase. The major work of the growth phase in-
volves updating the status of edges as to (1) which components contain their endpoints,
(2) whether another edge that joins the same components is effectively shorter, and (3)
the status (active or inactive) of their endpoint components. During a component merge,
our implementation currently takes time proportional to the number of undominated edges
leaving the two components involved. With a more intricate implementation, this should
be reducible to something proportional to the out-degree of the smaller component, which
might make a substantial difference on instances such as ours, where many components are
38
initially inactive ones consisting of a single prize-less vertex with low degree.
3.2.2 Solution quality
To compare the performance of strong pruning against GW-pruning in the context of the
rooted variant of the problem, we ran the two implementations of the GW-algorithm on
each testbed instance with a set of 100 randomly chosen roots. We then compared for each
instance the averages (of 100) GW objective function values obtained with GW-pruning
and strong pruning. Notice that this is equivalent to taking the average of 100 comparisons
of individual values produced for each root.
As can be seen from Tables 3.4, the average improvement in the GW objective function
due to strong pruning is significant: GW pruning yields solutions that are 1.7 to 9.2% worse
for the street map instances. Comparable improvements occur for the random unstructured
instances, and even bigger ones (10% and more) occur for the random geometric graphs.
Still bigger improvements occur for the NW objective function: over 20% for three of the
street map graphs and over 200% for all the random geometric graphs. (For these the
GW-algorithm produces solutions with negative Net Worth.)
Note also, that even if one takes the best solution over 100 roots, GW-pruning does not
do better than the average for strong pruning except on the smallest of the random graphs
and one of the 12 street map instances.
Thus, although GW-pruning has value as a proof technique, there would appear to be
strong empirical support for using the simpler strong pruning approach in practice (although
we shall have more to say about this in Section 4.2).
Table 3.4 also summarizes results for a way of improving on strong pruning: Postprocess
the tree by computing a minimum spanning tree (MST) on the vertices it contains. Note
that there is no reason to believe that a GW-type algorithm will produce a minimum
spanning tree, and our results confirm this. Typical improvements are 0.2% or more, with
significantly larger improvements for the unstructured random graphs. The tables report
only the improvement over average strong pruning results, but similar improvements apply
to the other GW-algorithm variants. Since the time for computing an MST is negligible
compared to that for the overall algorithm, this is definitely a worthwhile augmentation to
the algorithm. We also investigated a postprocessing phase that took the non-zero prize
vertices found by the algorithm and used the Goemans-Williamson Steiner Tree heuristic
39
Streetmap Graphs Rooted Growth Unrooted GrowthGW Pruning Strong Pruning Strong Pruning
County Average Best Ave NW Best +MST Average Bestof 100 of 100 overall
Cook IL +3.0% +2.8% +1.7% -.07% -.35% +.04% +.03%Dallas TX +4.9% +4.5% +6.2% -.21% -.21% -.01% -. 05%Wayne MI +5.2% +5.0% +14.5% -. 12% -. 18% -.02% -. 07%
King WA +1.7% -1.1% +1.6% -2.76% -.30% -.02% -2.75%Suffolk NY +6.4% +5.6% +21.9% -1.05% -.23% -. 01% -1.03%Nassau NY +1.9% +1.7% +1.3% -.06% -.32% -.03% -.05%
Oakland MI +7.5% +6.3% +28.3% -. 31% -. 34% -. 01% -.23%Franklin OH +5.8% +5.4% +11.9% -.23% -. 24% -.04% -.20%
Duval FL +5.3% +4.7% +14.3% -. 82% -.35% -. 01% -.61%Jefferson KY +9.2% +8.6% +46.9% -. 36% -. 18% -.00% -.27%
Montgomery MD +2.3% +1.5% +1.8% -. 21% -. 34% -.07% -. 19%San Mateo CA +2.6% +.4% +1.5% -2.24% -. 16% -.09% -2.24%
Random Graphs Rooted Growth Unrooted GrowthGW Pruning Strong Pruning Strong Pruning
Type Vertices Average Best Ave NW Best +MST Average Bestof 100 of 100 overall
Geometric 100 +18.5% -11.4% +395.5% -13.88% -. 21% -.02% -13.88%400 +14.0% +8.8% +424.2% -4.07% -. 28% -.09% -4.16%
1,600 +13.2% +8.3% +683.2% -1.63% -.36% -.07% -1.42%6,400 +10.3% +9.6% +245.0% -.45% -.40% -.09% -.32%
25,600 +10.2% +8.6% +217.2% -. 17% -.43% -. 02% -.09%Un- 100 +3.2% -4.2% +3.5% -5.84% -1.03% -. 18% -3.67%Structured 400 +3.5% +1.0% +4.5% -1.60% -.89% -. 10% -1.09%
1,600 +4.5% +2.5% +5.4% -. 90% -.89% -.07% -.63%6,400 +4.0% +3.0% +4.7% -. 18% -.88% -.07% -. 13%
25,600 +4.0% +2.2% +4.9% -. 95% -. 94% -. 10% -.95%
Table 3.4: Results for variants of the GW algorithm, expressed as percentage improvements
(negative numbers) or degradations (positive numbers) compared to the average result forrooted strong pruning, over a selection of 100 different choices of root vertex. All columnsexcept the "Ave NW" column concern the GW objective function; the latter concerns theNew Worth objective function. The "+MST" column represents the average improvementobtained by using a minimum spanning tree algorithm for post-processing.
40
to construct a (hopefully) better Steiner tree for them, followed by MST postprocessing.
Unfortunately, this was typically no better than doing the MST alone, and doubled the
overall running time.
3.3 Unrooted Growth
In Section 2.3.2 we presented another modification to the GW-algorithm - the unrooted
growth phase. The unrooted growth phase followed by rooted/unrooted pruning yields a
(2 - 1)-approximation algorithm for the rooted/rootless PCST problem. The degradation
in the theoretical guarantee is due to the modifications in the growth phase. However, these
modifications allow us to construct trees for more than one choice of root with a single run
of the growth phase. Moreover, it is not clear whether using unrooted growth in place of
the rooted growth phase would be actually worse in practice.
Our experimental results reported in Table 3.4, demonstrate that using the unrooted
growth phase can be advantageous in some cases, and disadvantageous in others.
Interestingly, when solving the rooted variant of the PCST problem, the average GW
values (over 100 different roots) for unrooted growth followed by (rooted) strong pruning are
typically better than the averages for rooted growth phase with strong pruning, although
only slightly (less than 0.1% - see column 7 of Table 3.4), for all three classes of instances.
However, for the unrooted variant of the problem, the best value obtained with the rooted
growth/strong pruning algorithm over a selection of 100 distinct roots is typically better
(although again by less 0.1%, except for the two smaller classes of unstructured random
instances) than the best value given by the unrooted growth/global strong pruning algorithm
(see columns 5 and 8 of Table 3.4). However, the latter can be computed much more quickly
using the rootless global strong pruning of Theorem (2.8). Also note that if all we want is
a solution for a specific root, the slight advantage in average GW value for the unrooted
growth version is often offset by a substantial disadvantage in running time, with the penalty
being as much as a factor of 2, although typically being more like 1.5 (see Table 3.3).
3.4 Closeness to Optimality
Although we cannot address completely the question of how close to optimal these algo-
rithms are in practice (mostly due to infeasibility of obtaining exact solutions for large
41
Without MST With MSTType No. No. No. Ave. Max No. Ave. MaxInstance Vert. Inst. Opt. Gap Gap Opt. Gap GapGeometric 100 11 10 .20% 2.25% 10 .20% 2.25%
400 11 3 1.04% 3.35% 4 .90% 3.35%Unstructured 100 5 0 3.60% 6.98% 0 2.97% 6.94%
400 5 0 3.03% 4.45% 0 2.14% 4.21%OR-Lib 500 34 7 4.65% 18.18% 7 4.07% 18.18%
1000 29 7 4.12% 15.39% 8 3.80% 15.39%
Table 3.5: Comparison of solutions obtained by the GW-algorithm using unrooted growthand global strong pruning to the optimal solutions for instances where the latter have beencomputed [13].
instances), whatever limited evidence we do have is suggestive. Lucena and Resende
have developed a branch-and-cut optimization algorithm for the unrooted variants of GW-
minimization and NW-maximization problems [13], which they have successfully applied
to all of our instances with 400 or fewer vertices (all of which are random graphs), as well
as some variously structured 500- and 1000-vertex instances derived from Steiner Tree test
cases in the OR-Library [4] by randomly assigning prizes to the required vertices. Here
the appropriate point of comparison is our rootless variant of the GW-algorithm that uses
unrooted growth and unrooted global strong pruning, since optima are being computed for
the unrooted variant of the problem. Table 3.5 reports on the gaps found between this
algorithm's solutions and the optimal ones for those instances that Lucena and Resende
have successfully solved. These results suggest that in practice the distance from optimality
increases as instances get larger, although it leaves hope that the the average gap may be
converging to something like 5%.
3.5 Further Improvements
In the previous sections we have presented a number of modifications to the GW-algorithm's
growth and pruning phases that lead to better results in practice. An alternative way to
obtain improvements from the GW-algorithm is to modify instances themselves in order to
force certain kind of behavior of the algorithm.
One such approach is to scale uniformly node prize values or edge costs. The GW (as
well as NW) objective function treats prize and edge costs symmetrically, assuming they
42
06
CD
,~J.~
C14J
I..-
0r-.
CDCD
1000 Node Unstructured Random Graph
-
I I I I I I 1 10.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0
PRIZE MULTIPLIER
Figure 3-3: Value of GW-objective function (using original prize values) as a function ofprize multiplier for rooted strong pruning and a random graph with edge probability 0.1, alledge weights equal to 100, 000, and nonzero prizes on 10% of the vertices, with prize valuesdistributed uniformly between 0 and 200,000. The best choice for the prize multiplier isabout a = .795, yielding a value for the GW objective function that is 2.7% better thanthat for a = 1.
43
z0I-0zIL
0
are measured in the same units. However, the "stronger" approximation guarantee for the
algorithm is not symmetric with respect to edge costs and prizes (e.g see Inequality (2.6)).
This suggests that the algorithm might be implicitly measuring prize values and edge costs
in different units. In studying the effect of scaling all the prize values by a multiplier p,
we observed that for both pruning rules, the best trees with respect to the original GW-
minimization problem are often obtained by using multipliers less than 1, i.e., by tricking
the GW-algorithm into thinking it has less prize than it actually does, e.g., see Figure 3-3.
This is common for GW-pruning, which as we have already seen leaves much room for
improvement when the multiplier is 1. Here values of p as small as .5 on occasion yield
the best results. For strong pruning, the effect is much less pronounced, although for the
unstructured random instance in Figure 3-3, we did get an improvement of 2.7% by taking
= 0.795 for our default choice of root.
To find such improvements, one must run the GW-algorithm many times. A perhaps
more promising way to exploit multiple runs is in the context of multiple-start local opti-
mization, as is currently being explored by Canuto et al. [7]. Here one repeatedly runs the
GW-algorithm on minor random perturbations to the instance, using the results as start-
ing points for a sophisticated local improvement algorithm. On the instances with known
optima covered in Table 3.5, a "best-of-500-starts" version of this algorithm averages less
than 1% above optimal for each of the classes of problems covered [15]. Simply running
the local improvement algorithm on the output of one run of the GW-algorithm also yields
measurable (but significantly smaller) improvements. -
44
Chapter 4
Bicriteria Optimization Problems
Both the GW-minimization and NW-maximization problems combine edge costs and node
prizes (penalties) in the objective functions, while imposing the constraint that the structure
returned is a tree. Such a model would only work only if the two weight functions are
comparable, i.e. measured in similar units. Moreover, in practice one might be interested
in optimizing only one of the cost/penalty functions while allowing another to take on values
within some range. In this chapter we will be considering two such bicriteria optimization
problems based on the Prize Collecting Steiner Tree problem scenario. We will present some
theoretical approximation results as well as some practical heuristics. We will also explore
some questions that are likely to be of particular practical interest in connection with these
problems.
4.1 The Quota Problem
In this variant of the Prize Collecting Steiner Tree problem we are given a prize quota
Q > 0 and the goal is to find a tree of minimum edge cost which spans a total prize of
at least Q. Notice that the well-studied k-MST problem, in which given an edge-weighted
graph G and a positive number k, one wants to find a minimum cost tree containing at
least k vertices, is a special case of the Quota problem in which all prizes are set to 1 and
the quota to k. Recently, a number of constant-factor approximation algorithms have been
developed both for the rooted and unrooted variants of the problem [6, 9, 2, 1]. The current
state-of-the-art result is (2+ E)-approximation guarantee. All of these algorithms are based
on the Goemans-Williamson original algorithm for GW-minimization. We show, in turn,
45
how to exploit these algorithms to solve the more general quota problem.
4.1.1 Approximation algorithms
Suppose we are given graph G = (V, E) with non-negative edge costs ce and strictly positive
integer node prizes 7r,. Let H be the total prize on all the nodes of the graph H = Z:,v r.
As a thought experiment, we transform graph G into G' with H nodes by substituting every
vertex v by a star with a center node v' and 7rv - 1 leaves all attached to v' by zero-cost
edges. Clearly, solving prize-collecting steiner tree problem on G with prize quota Q is
equivalent to solving k-MST problem on G' with k = Q.
Additionally, we might have to deal with zero-prize nodes. Since there is no easy way to
get rid of such nodes without changing the structure of the original graph, we will modify
prize values so as to get an equivalent instance of the quota problem with only positive
prizes on the nodes. The new prize assignment is frv = 2 lVi -irv + 1 for all nodes v. Notice
that all nodes now have positive integer prizes assigned to them. We also scale up the prize
quota to be Q = 2 lVi -Q. We now verify that any tree that is optimal for the quota problem
under the modified prize assignments is optimal for the original problem.
Lemma 4.1. If tree T is an optimal solution to the Quota Prize Collecting Steiner Tree
problem under modified prize assignment *r with target prize set to Q, then T is an optimal
tree for the original instance of the problem.
Proof. First we need to show that any tree T that is feasible under the modified prize
assignment is also feasible under the original prize assignment. Consider a tree T such that
fr(T) Q = 2 Vi - Q. Rewriting the modified prize total for T in terms of original prize
total, we obtain fr(T) = 2IVI-ir(T)+ITI 2IVIQ. Since T spans no more than iVi vertices
and all the prizes as well as target Q are integers, we must have that 2 lV I- 7r(T) 2 VI - Q.
It clearly follows that ir(T) Q, i.e. tree T is feasible under the original prize assignment
as desired.
Next we prove the optimality statement by contradiction. Suppose there exists another
tree T', such that cost(T') < cost(T) and ir(T') > Q. Notice that edge cost of any tree is
the same for two instances since it does not depend on prize values. Since tree T is optimal
for the instance with modified prizes, tree T' must be infeasible for this instance, i.e. the
46
prize value of T' under fr doesn't reach the target Q. Let us compute this value:
ft(T') = 2|IVI - r(T') +T'| ;> 2|V| -Q = Q.
Thus, T' must collect enough prize value under the new assignment of prizes, and thus we
get a contradiction. [
Combining the above two techniques we can transform any instance of the Quota prob-
lem with integer prizes into an instance of the k-MST problem, which can then be ap-
proximately solved by any known constant-factor approximation algorithm. Note that the
approximation guarantee is preserved, since edge costs are not modified in creating a k-MST
instance. However, since the running time is a function of the number of vertices in the
graph, and our transformation creates may new vertices, we get only a pseudo-polynomial
approximation algorithm.
However, if we were to use Garg's 5-approximation or 3-approximation algorithms [9],
there is no need to explicitly perform the "prize-to-vertices" construction on a graph. The
GW-algorithm, used by Garg as a main subroutine, would "collapse" all leaves attached
by zero-cost edges into their respective star centers in the first step. Moreover, if a tree on
G' contains any one of the "artificial" star leaves, then it must contain the center node of
that star as well, which means that we can add to the tree the rest of the leaves of this star
without increasing the cost of the tree. Hence, for the purposes of the k-MST algorithm
it doesn't make sense to consider artificial nodes individually. We can keep them collapsed
together and adjust the rest of the steps of the algorithm to deal with the whole cluster of
nodes as a unit. Thus we obtain a 3-approximation algorithm for the Quota problem.
Theorem 4.2. There exists a polynomial-time 3-approximation algorithm for the Quota
problem which first constructs an equivalent instance of the k-MST problem and then uses
Garg's 3-approximation algorithm to solve it.
4.2 The Budget Problem
In the Budget variant of the Prize Collecting Steiner Tree problem, we are given an upper
bound B to pay for edges and the goal is to find a tree containing the maximum amount of
prize whose edge cost is no more than B.
47
Suppose we ran our 3-approximation algorithm for the Quota problem with prize quota
value set to Q and obtained a tree of cost C. Then by increasing the quota value sufficiently
we will obtain a tree of cost more than C. Now, by repeatedly running the Quota algorithm
and using a binary search on the quota values, we can find a value q* such that the tree
produced by the 3-approximation Quota algorithm from the previous section for prize quota
q* costs no more than B and any tree output by the algorithm for quota value q*(1 + E)
costs more than B for a given value e > 0. We output the tree for q*, which is guaranteed
to contain total prize within a factor of 5 from the optimal value. Binary search to finite
precision suffices, since there exists an exponentially small 3 such that two trees produced
by the algorithm for prize quota values qi and q2, s.t. 1qi - q2I 5 6, must have the same
edge cost.
Theorem 4.3. Given a polynomial-time 3-approximation algorithm for the Quota problem,
the binary search approach yields a polynomial-time (5 + e)-approximation algorithm for the
unrooted Budget PCST for any e > 0.
Proof. Suppose we are given an instance of the Budget PCST problem with budget value B.
Let T* be the tree output by the binary search algorithm and let q* be the corresponding
quota value. By construction, any tree produced by our Quota algorithm for quota value
q*(1 + c) has edge cost greater than B. We will show that any tree with edge cost bounded
by B (an optimal tree in particular) contains total prize less than q* (5 + e).
Since we know that our Quota algorithm is a 3-approximation algorithm, any tree with
prize value q* (1 + E) must cost more than B/3. Suppose that there exists a tree with a prize
value at least 5(1 + e)q*. Then, as will be demonstrated below, we can partition this tree
into 3 edge-disjoint subtrees, each with prize value of at least 1 / 5 th of the total 5(1 + e)q*.
But then each of the subtrees must contain at least (1 + E)q* prize and hence must cost
more than B/3. This results in a contradiction since the whole tree cannot have edge cost
of more than B. E
In order to get a better approximation guarantee for the Budget PCST problem with
the above technique, we will need an a-approximation algorithm for Quota problem with
a < 2. For example, by using a 2-approximation algorithm for the Quota problem we would
obtain a tree with total prize value within 3(1 + e) of optimal, since (as will be shown below)
any tree can be partitioned into 2 edge-disjoint subtrees each containing at least 1 / 3 rd of
48
the total prize value.
4.2.1 Trisection of a Tree
In the above proof we have used a fact that a given tree can be partitioned into 3 edge-
disjoint subtrees each containing at least 1 / 5 th of the total prize value. In this section we
will establish this result in full detail.
Let us define an ordering relation on node-weighted trees. Given 2 trees T and T2, let
us say Ti -< T2 if either w(Ti) < w(T 2), where w(T) denotes the total weight of all nodes
of a tree T, or w(Ti) = w(T 2) and Ti contains fewer nodes than T2 . Also, Ti -< T2 if either
Ti -.< T2, or w(Ti) = w(T 2) and Ti contains the same number of nodes as T2.
Definition 4.4. A tree T is -<-minimum with respect to a set of trees T, if for any tree
T' E T, T -< T'. Similarly, a tree T is -<-maximum, if for any tree T' E T, T' - T.
We will limit our attention to the case in which no negative weights are allowed. First
we will demonstrate a simpler result for partitioning a tree into 2 edges disjoint subtrees.
Lemma 4.5. Any node-weighted tree, in which no node has weight more than 1 / 3 rd of the
total weight of the tree, can be split into 2 edge-disjoint subtrees, such that each one of them
contains at least 1/ 3rd of the total weight
Proof. For simplicity let us assume that the total weight of all nodes in the tree is 1.
Consider all the possible edge-disjoint splits into two subtrees, in which the smaller subtree
weighs less than 1/3. Let T be a set of all smaller subtrees obtained from such splits. Let
T, be a -<-maximum subtree with respect to the set T. Take the edge-disjoint split which
produced TI. Denote by T2 the other subtree obtained by this split, and let v be the vertex
which is shared by the two subtrees.
If node v has only one adjacent edge e = (u, v) in T2, consider a new partition into T1, T2
formed by moving u together with edge e to Ti. w(T2) = w(T 2) - w(v) > w(T 2 ) - 1/3 > 1/3,
since in the original split w(T 2) > 2/3. Since T1 was formed by adding a node of non-
negative weight to T1 , T < Ti. But T, is a -<-maximum subtree of weight less than 1/3,
thus w(Tj) > 1/3, and so we have the desired split.
If vertex v has at least two children in T2, we can split T2 into 2 subtrees, both rooted
at v. The larger of the 2 subtrees must weigh at least 1/3 since w(T 2) > 2/3. Again, by
49
-<-maximality of T 1 , if we move the smaller subtree over to T 1, the weight of the new T
becomes at least 1/3. Since the other subtree weighs at least 1/3, we have the desired
split. -
We can obtain a split into 3 edge-disjoint subtrees by splitting a tree into two, and then
taking a larger subtree and splitting it again. By the above Lemma, each of the 3 subtrees
is guaranteed to contain at least 1 / 6th of the total prize. However, assuming that no node
has weight more than 1 / 5 th, we can strengthen the result of Lemma 4.5 to obtain a more
even split.
Lemma 4.6. Any node-weighted tree, in which no node has weight more than 1 / 5 th of the
total weight of the tree, can be split into 2 edge-disjoint subtrees, such that one of them
contains at least 1 / 5 th of the total weight and the other one contains at least 3 /5th of the
total weight.
Proof. For simplicity let us assume that the total weight of all nodes is 1. We will prove
our result by contradiction. Suppose that such split is not possible. This means that in any
split in which each subtree weighs at least 1/5, both of them must weigh at least 2/5.
By the previous lemma, there exists a split into 2 subtrees T and T2 such that both
subtrees have weight of at least 1/5. Wlog, suppose w(Ti) w(T 2 ). Among all such splits
let us consider the one in which T is -<-minimum, with respect to the set of all subtrees
formed by such partitions.
Recall that since w(Ti) 1/5, we must have that w(Ti) 2/5, otherwise the other side
weighs at least 3/5 and we have the desired split. Let v be the vertex shared by the two
trees. Vertex v must have at least 2 incident edges in T 1 . Otherwise, if it had only one such
edge, we could move it over to T 2 , thus removing vertex v from T and decreasing its weight
by w(v) 1/5. Since w(TI) 2/5, the new subtree must weigh at least 1/5, contradicting
our assumption that T was a -<-minimum tree with such weight. This means that v must
have at least 2 children in T 1 . Consider the subtrees rooted at these children. If we move
the smallest one over to T2, we get a new split into T1, T2 with w(T) : 1/2 - w(Ti) 1/5.
But T1' -< T 1 , once again contradicting the assumption that T 1 was a -<-minimum tree with
such weight. E
Theorem 4.7. Any node-weighted tree, in which no node has weight more than 1/5 of the
50
total weight of the tree, can be split into 3 edge-disjoint subtrees, such that each one of them
contains at least 1/5 of the total weight.
Proof. By the above lemma, there exists a split into 2 subtrees, such that the smaller subtree
weighs at least 1/5 and the larger subtree weighs at least 3/5. Since no node weighs more
than 1/5 < 1/3, we can take the larger subtree and split it further into 2 subtrees, each of
weight at least 1/3 of the total. It is easy to see that we obtain 3 subtrees, each containing
at least 1/5 of the total node weight. E
Remark 1. It is not possible to have a better guarantee than 1/5, i.e. there does not always
exist a 3-way split such that each of the subtrees weighs more than 1/5. Consider a star
with 5 leaves, each of weight 1/5. Let the center have weight 0. It is easy to see that any
split into 3 edge-disjoint subtrees contains at least one subtree of weight exactly 1/5.
4.3 Practical Heuristics
We probably will never want to use any of the above approximation algorithms directly
in practice. However, some ideas inherent in Garg's 3-approximation algorithm for the
Quota problem can be adapted to yield quite practical heuristics for the Quota and Budget
problems. In this section we describe such an approach for the Quota problem and then
extend it to the Budget problem.
4.3.1 Prize-multiplier approach
Consider an instance of the PCST GW-minimization problem. Suppose we run the GW-
algorithm on it and obtain a solution tree T. What is the total prize value of vertices in
T? That would depend on the relative value of vertices compared to the costs of edges:
intuitively, we would want to collect a prize from some vertex only if the cost of getting
that vertex is outweighed by the value of the prize. Thus, if the solution tree does not
contain enough prize, in order to force the algorithm to "collect" a greater amount of prize,
we could sufficiently increase the prizes of vertices, in order to offset the edge costs. By
scaling prize values of vertices up or down, we can control the value of prize picked by the
algorithm. This is essentially the basis for our prize-multiplier heuristic.
The idea (which is also implicit in Garg's algorithms) is to run the GW-algorithm on
a series of PCST instances, each obtained from the original instance I by multiplying all
51
prize values by a fixed prize multiplier p. Let I, be the instance derived using multiplier p.
Given a Quota Q and a small fixed E > 0, one uses binary search to find a value of p such
that the tree generated by the GW-algorithm for I,, has total prize Q or more (as measured
in terms of the original instance I), but the tree generated for I(,+,) has total prize less
than Q. One then either returns the first tree or, if it has significant excess prize, tries to
find a better tree intermediate between the two trees.
We can motivate the prize-multiplier approach described above by considering an integer
program for the Quota problem modeled after the original GW IP.
Min E CeXeeEE
subject to:
EZXe +EZN > S CV -reEJ(S) NDS
SzN TZri ZriQ-
NCV-r iEN iEV
E ZN lNCV-r
XeZN E{0,l} NCV-r
We use the same set of variables xe for each edge and ZN for each subset of vertices. Just
as in the original IP, ZN is set to 1 for the set of vertices not spanned by the tree. To reflect
the quota requirement, we add an additional constraint that the total prize not collected
by the tree has to be more than the total prize amount in the graph minus the desired
amount of prize. Writing the quota constraint in this form is somewhat awkward, but it
uses the same variables as the original IP and yields a very similar dual program to the
52
linear programming relaxation:
Max EyS -,p(E ri - Q)S:r S iEV
subject to:
Z YS Ce ecES:eE6(S)
E1yS >Ep7ri NcV-rSCN iEN
PYS;> 0 SEV-r.
The new variable p serves as a multiplier on the node prizes. In fact, when P is fixed,
the second term in the objective function p (Eiy 7ri - Q) is constant, so solving this dual
program is identical to solving the original dual program with all the prizes scaled by p.
Intuitively, in order to get a tree with more prize, we need to increase the value of the prizes
to delay deactivation of components and enable the algorithm to add more edges. The same
argument with a multiplier between 0 and 1, applies to the case when target prize value is
actually less than what the GW-algorithm produces for the original instance.
While the prize-multiplier heuristic alone in general doesn't give any theoretical per-
formance guarantees, we get provably good solutions in some special cases. The following
theorem holds when we use original GW-pruning when running the algorithm.
Theorem 4.8. Given an instance I of the PCST problem, suppose that for some multiplier
value M,, the prize-multiplier heuristic outputs a tree T with exactly Q,, prize. Then T is
a 2-approximation for the PCST problem with quota value Q.
Proof. Consider instance I,, in which all prize values 7ri have been scaled by po. When we
run the GW-algorithm with GW-pruning on this instance, we obtain a tree To. The scaled
amount of prize not in To is po(EiEV ri - Qo). The GW-algorithm provides us with the
following approximation guarantee:
ce + po(Z7ri - Qo) 2 Z YS.eET iEV S:r S
The original proof of the algorithm's approximation factor (Theorem 4.1 in [10]) can be
used to demonstrate a slightly stronger result (similar to Remark 2.3.2). In particular, in
53
root
5
4.9 5010
Z10.4
5,25
a)
root
B
C
b)
roo
A B
(j
c)
Figure 4-1: Example demonstrating nonmonotonicity of the growth phase of GW-algorithmas a function of increasing multiplier values. a) Original graph with prizes and edge costs.b) Solution obtained on the original graph. c) Solution obtained with prize multiplier 1.025.
our case
ce + 2 -po(l7ri - Qo) 2 Z YSeET iEV S:roS
Rearranging the terms, we obtain that
Ce 2( YS - P(Z7ri - QO)e6T S:rgS iEV/
Notice that the right-hand side of this inequality is the objective function of the dual of the
Quota problem LP. Thus, the cost of To is at most twice the optimal, implying that the
tree To is a 2-approximation to the Quota problem with quota value Q. E
4.3.2 Nonmonotonicity of the prize-multiplier approach
Using the above intuition, one might hope to run the algorithm once, solving for all values of
the multiplier M simultaneously. Unfortunately, this is not possible because a tree obtained
with a larger multiplier value might not contain a tree that an algorithm would construct
with a smaller multiplier. Such nonmonotonicities can be due to a growth phase and/or
pruning phase. An example in Figure 4-1 illustrates nonmonotonic behavior of the growth
54
root
8
A 205
4.85.01
).99
a)
root
A -- .B
C
b)
Figure 4-2: Example demonstrating nonmonotonicity of the growth phase with strong prun-ing as a function of increasing multiplier values. a) Original graph with prizes and edgecosts. b) Solution obtained on the original graph. c) Solution obtained with prize multiplier1.2.
phase. When the GW-algorithm is applied to the original instance (1) the component A
freezes before reaching the root; (2) the component containing B merges with it, making an
active component AB, (3) components AB and C merge with each other; (4) the component
ABC joins the root. However, once all prize values are multiplied by 1.025, the component
A now has enough prize to pay for the edge to the root. Thus, events take place in the
following order: (1) the component A joins the root; (2) the component B merges with the
root; (3) the component C becomes deactivated. In this case, the component containing
C runs out of prize and freezes before it can merge with B, since B stopped helping it
to pay for the edge (B, C) once it joined the root. As a result, the tree obtained in this
case contains A and B, but not C, whereas the tree solution for the original instance spans
all three vertices. If we applied strong pruning to the tree obtained on the original graph,
vertex C would be pruned off anyways, since it has much less prize than the cost of the
edge (B, C). GW-pruning would have to keep C, since it was never deactivated.
However, strong pruning cannot always fix the problem created by the growth phase.
An example in Figure 4-2 illustrates a slightly different nonmonotonicity in the growth
phase complicated by strong pruning. In this case, the two trees obtained after the growth
55
root
A B
C
0)
A205
root
B4
Figure 4-3: Example demonstrating nonmonotonicity of the optimal solutions to the Quotaproblem.
phase span the same set of vertices, but use different edges. When the GW-algorithm is
applied to the original instance, the order of events is following: (1) component A freezes, (2)
components B and C merge using edge (B, C), (3) component BC merges into A using edge
(A, C), (4) ABC joins the root. However, when the algorithm runs with prize-multiplier 1.2
the order of events changes, and a different set of edges is used: (1) the component A has
enough prize to merge with C; as a result, (2) B uses edge (A, B) to join with AC (since it
is shorter than previously used edge (B, C)); (3) ABC joins the root as before. However,
because of the different structure of the tree after the growth phase, strong pruning removes
vertex C.
The nonmonotonicity property illustrated above is not just the "weakness" of the GW-
algorithm. Optimal solutions for different values of quota are not necessarily monotonic in
the solution structure as a function of the prize quota value. As a simple example, consider
the graph pictured in Figure 4-3. Optimal solutions to the rooted Quota problem with
prize target values 4 and smaller consist of the root and vertex B. However, for prize quota
values in the interval (4,20], an optimal solution contains vertex A but drops vertex B.
4.3.3 A pruning heuristic for the Quota problem
With a prize-multiplier approach, using a sufficiently big multiplier, it is always possible to
obtain a tree with node prize totaling at or exceeding a given prize quota Q (provided the
graph has a connected component containing at least that much prize). We can hope that
56
Montgomery County, MD100
80
CO
M60--0
C
40 -
a.
20
20
0 : p I I
0 0.4 0.8 1.2 1.6 2Prize Multiplier
Figure 4-4: Percentage of prize obtained as a function of prize multiplier.
if we increase the multiplier slowly, we can obtain a relatively continuous range of prize
values. However, this is not always the case and there exist discrete gaps in prize values
(for example, see Figure 4-4). Also, re-running the GW-algorithm with a large number of
multiplier values to avoid the gaps can be very time consuming. An alternative approach
can be employed to fill in the gaps: taking solutions with higher prize values than desired
and pruning them down so as to decrease edge cost.
Suppose we run our algorithm with two multipliers pi and p2 and obtain solution trees
with prize values P and P2 with P < P2 . Additionally, suppose we are given prize quota
Q falling between the two prize values: PI < Q < P2 . While tree T 2 is a valid solution for
the Quota problem with target value Q, it might be possible that there exists a subtree of
T2 which is also a valid solution and has smaller edge cost. Using dynamic programming
we can find an optimal min cost subtree of T2 which satisfies prize quota Q. However, this
approach is quite expensive computationally (unless all the prize values are the same) and
one might instead desire a fast heuristic that can find such a subtree (possibly suboptimal).
57
Finding a min cost subtree of a tree can be viewed as pruning away unnecessary prize
while trying to decrease edge cost as much as possible. Intuitively, we would like to remove
subtrees that have high edge cost per unit of prize. Since we are interested in the relative
values of edge costs and node prizes, let us introduce the following notion of a cost-prize
ratio.
Definition 4.9. Given a rooted tree T, consider a subtree Tu rooted at a vertex u. Let us
denote by 1(u) the total prize value of all the vertices in T, [1(u) = ZiTu 7ri and by C(u),
the total cost of all edges in T, C(u) = ZeTu ce. Define the cost-prize ratio of a subtree
Tu rooted at a node u is the ratio of the combined cost of all edges in that subtree plus the
cost of an edge (v, u) connecting u with its parent v to the total prize value in T,. Let us
denote this ratio by R(u)
R(u) = .(u) + cUH(u)
Given a tree T and a target quota value Q, our pruning heuristic repeatedly prunes
away subtrees of T with the largest cost-prize ratio until no vertices can be removed without
bringing the total prize value H of the remaining tree below quota value Q.
QUOTA-PRUNE(T, Q)
1 sort all subtrees T, on their cost-prize ratio R(u)
2 for each Tu in decreasing order of R(u)
3 do if H(T) - H(Tu) > Q
4 then prune T. from T: T +- T - Tu
5 update R(v) for each v on the path u -+ root
We can think of this approach as an extension of strong pruning - components whose
net worth is less than the cost of the edge attaching them to the rest of the tree have the
highest cost-prize ratios and will be removed first.
The running time of this heuristic is O(n 2 log n) in the worst case, where n is the number
of nodes in the tree from which we start. Notice that it is bounded by the total number of
nodes in the original graph. Initial ratios can be computed recursively in one pass over the
tree in linear time and then inserted into a heap in O(n log n) time. In each iteration O(n)
elements of the heap have to be updated or deleted. There can be at most n - 1 iterations,
since in every iteration at least one element is removed from the heap.
58
4.3.4 Heuristics for the Budget problem
The (5+c)-approximation algorithm for the Budget PCST presented in the previous section,
solves the problem indirectly by repeatedly solving the Quota problem for different target
prize values. Instead, we can apply the prize-multiplier heuristic directly to get a solution
for the Budget PCST, similar to the way we used for the Quota problem.
In this case, given a budget value B and a small fixed E > 0, we run the GW-algorithm
with a series of multipliers, performing binary search on the edge cost of the trees produced.
Once we find a multiplier M such that the tree T, generated with a multiplier 1 has cost
at most B while the tree T,(l+E) generated with multiplier p(1 + c) costs more than B, we
output the tree for T,.
If there is a significant gap in the amount of prize contained in T. and T,(+,), one
might want to try to find a tree intermediate between the two trees. Once again a pruning
heuristic similar to quota pruning can be used. In this case, we take the tree T,(,+,) and
prune away subtrees with high cost-prize ratio until the remaining tree's cost drops to or
below the budgeted amount B.
BUDGET-PRUNE(T, B)
1 sort all subtrees T on their cost-prize ratio R(u)
2 for each Tu in decreasing order of R(u)
3 do v +- parent(u)
4 if C(T) - (C(Tu) +cuv) > B
5 then prune Tu from T: T +- T - Tu
6 update R(v) for each v on the path u --+ root
7 else break cycle
8 > set of all subtrees whose removal drops edge cost to B
9 S +- {Tuju E T,C(T) - (C(Tu) +cu,) < B}
10 pick Tu E S with min H(Tu)
11 prune Tu from T: T +- T - Tu
Notice that we are careful in picking the last subtree to remove - among all subtrees
whose removal would bring the edge cost to be within the budget, we pick the one that
contains the least amount of prize, so as to maximize the total prize left in the tree.
59
Chapter 5
Experimental Results for the
Prize-Multiplier Approach
5.1 Cost/Prize Tradeoff
In trying to understand the performance of the prize-multiplier approach, a natural object
to study is the "tradeoff curve" obtained by plotting the (prize, cost) pairs (original, not
multiplied prizes) obtained for various multiplier values p. Figure 5-1 illustrates such a
curve for one of our street map instances. This curve was obtained using the rooted growth
phase with GW-pruning plus MST-postprocessing, with p increasing from 0.2 to 8.469 by
factors of 1.01. (In the remainder of this chapter, we concentrate for specificity on the
rooted version of the problem.) Note that no trees were found between the empty one
consisting only of the 0-prize root, and the one that contains 28.7% of the total prize. Such
an initial gap is a common phenomenon for instances like ours with most vertices having
prize 0, but note that unless our quota was in that gap, we would likely be happy to settle
for the tree of lowest cost that contains enough prize, without resorting to the complicated
heuristic Garg invokes to find an intermediate tree.
For big gaps like the initial one, we can use QUOTA-PRUNE with the desired target quota
value (as described in Section 4.3.3). Figure 5-2 shows the result of using this approach for
multiple quotas so as to fill in the early gaps in the tradeoff curve of Figure 5-1. We used
evenly separated target prize values designed to obtain points every 1% or so. Note that
for each gap in the original curve, the interpolated points do not rise substantially above
60
Montgomery County, MD
40 60Per Cent of Prize Obtained
Figure 5-1: Tradeoffs between cost and prize obtained by varying the prize-multiplier.
61
700 k
600 -
500
4000,00DCD)
I/
300 k
200 -
I
100
100
00 20 80
I i I I
+4w
I I I I
Montgomery County, MD
0L
++
+
+
+
10 20Per Cent of Prize
Figure 5-2: Interpolating into the gaps of the prize/costgreedy pruning.
30Obtained
40 50
tradeoff curve of Figure 5-1 using
62
140
120 k-
++
±-I-
100 1-
+4
4+
+
+
801-0,0
w 60 -
40
20+
+
+
4.
00
I , I I
'I 'I 'I '
the straight lines linking the data points at the top and bottom of the gap. Even better
results can often be obtained for a given quota by greedily pruning from several different
trees above the gap, and taking the best result. One also gets reasonable results even if one
generates the initial tradeoff curve using a larger growth factor for A than the factor of 1.01
used here (thus computing fewer points and saving considerable computation time). An
analogous pruning approach also appears to work well for the Budget problem. Note that,
for our application, the tradeoff curve itself may well be of more value than the solution to
any particular instance of the Budget or Quota problem, since network planning typically
has to optimize over a range of possibilities.
5.2 Nonmonotonicities in the tradeoff curves
Moreover, the curve turns out to be a fascinating subject of study in its own right, providing
many surprises. For instance, although Figure 5-1 provides what appears to be a nicely
monotonic curve, this is not always the case: for some instances, certain values of A can
produce trees that are totally dominated by others, i.e, have less prize and yet cost more.
Indeed, a closer inspection of seemingly monotonic tradeoff curve of Figure 5-1 shows that
even it is riddled with such nonmonotonicities. See Figure 5-3.
This phenomenon is caused by the nonmonotonic behavior of the GW-algorithm. In
Section 4.3.2 we provided a few artificial examples, in which increasing the prize multiplier
p caused the GW-algorithm to actually exclude some vertices previously in a solution,
resulting in the decrease of the prize value of the solution. Our experiments demonstrate
that such behavior is not uncommon in practice. It is especially noticeable under the strong
pruning and occasionally present under the GW-pruning. See Figure 5-4, which tracks the
percentage of prize obtained as function of p under rooted growth for both GW-pruning
and strong pruning. Nonmonotonicities clearly occur frequently in the strong pruning curve.
There are also a few in the curve for GW-pruning, although it is difficult to see them at
this level of resolution.
5.3 Comparing tradeoff curves
For a given multiplier /p, strong pruning typically results in significantly less prize than does
GW-pruning (as well as substantially less edge cost.) Thus it is hard to guess, a priori,
63
Montgomery County, MD
C'j00 -C,%j
(Dl- -C~j
++
++
+
+
+
+
++
+
+
+
+
+
++
I I I I I I
74.0 74.2 74.4 74.6 74.8 75.0
PERCENT OF TOTAL PRIZE OBTAINED
Figure 5-3: Closeup of the tradeoff curve of Figure 5-1 showing nonmonotonicities.
64
0
C\I
I-C)0
0aw
Montgomery County, MD100
80
60 -0a)
N
CIL 40 - 10
20
40 x
strong pruning +GW pruning x
0 1: l 10 0.2 0.4 0.6 0.8 1
Prize Multiplier
Figure 5-4: Percentage of prize obtained as a function of prize multiplier, both for GWpruning and strong pruning. Note the obvious nonmonotonicities in the latter curve. Thereare 3 nonmonotonicities in the GW pruning curve as well. Note that for a given prizemultiplier M, GW-pruning obtains a significantly higher proportion of the prize.
65
Montgomery County, MD
+
+ x/
++
+ ~
x
x
4-
+
+
+
+ x
strong pruningGW pruning-x
+x
59Per Cent of
61Prize
63Obtained
Figure 5-5: Close up of the tradeoff curves under strong pruning and GW pruning. Note
that GW-pruning provides a distinctly better tradeoff curve than does strong pruning.
66
220
215
210
205
U')0
0a>)CD
-0w
200
195
190
185
180
x
+ x
57 65II
I I I
x
whether the two methods yield the same- curves or, if not, which one yields the better
curve. Surprisingly, GW-pruning typically turns out to be the winner, despite the fact that
it is handily outperformed by strong pruning on the GW-minimization problem for which
it was originally designed. As a consequence of being more conservative, the GW-pruning
typically produces tradeoff curves with smaller gaps (especially the initial one) than the
ones yielded the strong pruning. Moreover, for a given target prize value, a feasible solution
produced with the GW-pruning usually costs less than the corresponding solution obtained
with strong pruning. Figure 5-5 provides a closeup of the portions of two curves, in which
the advantage of GW-pruning is clearly visible.
In order to confirm the existence of a consistent GW-pruning advantage, we need a way
of making quantitative comparisons between tradeoff curves. Note that our "curves" are
really just sets S of solutions. For a given set of solutions S and an x E [0, 1], let Cs(x)
be the minimum cost of a solution in S that contains at least x times the total prize. This
makes Cs a step function. A closeup of the step functions for a tradeoff curve generated with
GW-pruning is illustrated in Figure 5-6. Notice big steps in the function obtained using
only the original "raw" tradeoff data. The steps are much smaller once we use data points
obtained by filling in the gaps with the quota pruning heuristic described in Section 4.3.3.
Suppose we make a request for a random amount of prize, the amount chosen uniformly
between 0 and the total available prize. Then the expected cost E[S] that we will pay,
given that we are using S for our tradeoff curve, is E[S] = fo Cs(x)dx, and this seems a
plausible figure of merit for such a curve. We can easily compute this integral measure for
any data set, since Cs(x) is a step function. Note that filling the gaps in the curve using
the QUOTA-PRUNE heuristic should lower E[S] (see Figure 5-6), as should generating more
points in the first place using a smaller growth factor J = 1 + E.
5.3.1 Improvements due to interpolation
Let Sw and 56 be the sets of tradeoff points generated by GW-pruning and strong
pruning when the multiplier growth factor is 3. Let IS and ISip be the corresponding
"interpolated" point-sets obtained by using our quota pruning heuristic to fill all gaps larger
than 1% of the total prize. Presented in Table 5.1 are the percentage improvements in the
integral measure of IS6 over S6 for both GW and strong pruning. For the streetmap
instances, improvements are typically larger for the strong pruning curves, with the average
67
Montgomery County, MD
140 -
120
100
ri4 ~
+
4-4-
:4
'4.
i-i-
+4-A-
* r
80 -
601
4 0 k ------------- #'I..-r
-1-
-r1~
1~
I I
0 10 20Per Cent of Prize
30Obtained
Figure 5-6: The step function for the raw and interpolated cost/prize tradeoff curves.
68
4-00
0)-)VU
40 50
I I I
20
II I I
Streetmap graphs Interpolation Comparing 36 = 1.1 3 = 1.01 1.1 vs 1.01
GW Strong GW Strong GW Strong
County Pruning Pruning Pruning Pruning Pruning Pruning
Cook IL 2.32% 3.36% 0.41% 1.00% 4.00% 4.01%
Dallas TX 3.18% 3.30% 0.90% 1.04% 4.05% 3.79%
Wayne MI 6.16% 6.00% 3.26% 1.94% 4.62% 5.74%
King WA 6.53% 5.44% 3.61% 2.50% 4.41% 4.35%
Suffolk NY 9.18% 11.18% 8.01% 7.45% 2.79% 5.81%
Nassau NY 6.10% 15.66% 1.24% 6.59% 6.16% 6.86%
Oakland MI 2.23% 4.40% 0.60% 1.26% 3.82% 5.39%
Franklin OH 2.71% 3.23% 0.69% 0.91% 3.62% 3.75%
Duval FL 3.69% 6.46% 1.20% 3.01% 4.33% 5.64%
Jefferson KY 2.74% 3.55% 0.47% 0.63% 3.96% 4.40%
Montgomery MD 5.24% 6.96% 1.74% 4.66% 5.24% 3.78%
San Mateo CA 7.50% 8.34% 3.07% 3.19% 4.41% 4.92%
Random graphs Interpolation Comparing 66 = 1.1 6 =1.01 1.1 vs 1.01
GW Strong GW Strong GW Strong
Type Vertices Pruning I Pruning Pruning Pruning Pruning Pruning
Geometric 100400
1,6006,400
Unstructured 100400
1,6006.400
5.97%6.94%8.63%1.63%3.74%4.88%
4.89 %-' U L ______ J ______ - ______ -
20.23%21.50%14.74%11.97%17.99%
7.77%4.44%2.87%
16.23%18.97%15.24%16.57%11.73%7.03%6.26%2.81%
15.35%14.85%9.38%7.43%9.14%3.27%1.59%0.29%
Table 5.1: Comparison of the raw and interpolated tradeoff curves and of curves obtained
with two different multiplier growth factors 6, expressed as percentage improvements in the
step function integral.
69
'IH-
1. 18%5
5.56%7.30%
11.23%3.45%4.70%5.00%5.04%
19.94%16.69%9.27%5.02%
16.53%4.73%1.24%0.17%
improvement of E[IS'4] over E[Si4] at 6.5%, compared to 4.8% for the GW-pruning.
Notice that the percentage improvements decrease for the tradeoff curves generated with
the smaller multiplier growth factor 6 = 1.01.
The percentage improvements for the random geometric instances decrease more as
a function of the number of vertices, with the numbers ranging from 20% for 100-node
instances to 5% for 6,400-node instances. This effect is even more pronounced for the
random unstructured graphs. Interestingly enough, for smaller 100- and 400-node instances
in both classes of random graphs, the effects of interpolation are stronger for the GW-
pruning than for the strong pruning, with the trend reversing for 6,400-node instances. We
will look at this phenomenon in more detail a little bit later.
5.3.2 Improvements due to varying multiplier growth factor.
Table 5.1 summarizes statistics for another way of improving the tradeoff curves - gen-
erating more points by using a smaller growth factor 6. For the streetmap instances, the
improvements are about the same for the GW-pruning and the strong pruning, with average
improvement of E[Sg] over E[S'v] at 4.41%, and the average improvement of E[Si']
over E[Si4] at 4.92%. For the random graphs, improvements increase as a function of the
number of nodes both for the geometric and unstructured instances. This suggests that
points to the discreteness of the GW-algorithm: it can add on only discrete chunks of prize
contained in entire components, resulting in gaps in the tradeoff curves. This situation
cannot be rectified by varying prize multiplier even slower. Thus, it seems that for graphs
of small size, using our quota pruning heuristic is the most effective way to fill in the large
gaps. Although for graphs of larger size (over 5,000), overall improvements obtained with
interpolation are comparable to the improvements due to the smaller growth factor, the for-
mer is still indispensable for filling in initial large gaps which are smaller but still common
when the latter approach is used.
5.3.3 GW-pruning advantage.
In order to test whether there exists a widespread GW-pruning advantage, we have com-
pared integral measures of the tradeoff curves (both raw and interpolated) generated with
values of 6 = 1.1 and 6 = 1.01. The Table 5.2 summarizes the comparison statistics. For
our streetmap instances, E[S'1] < E[S '] for 11 of the 12 instances, with an average gap
70
Streetmap graphs Multiplier growth factor3 = 1.1 6 = 1.01
Type Vertices Raw Interpolated Raw Interpolated
Geometric 100 -5.05% 0.35% -5.85% 0.15%400 -1.79% 2.07% -1.37% 1.51%1600 1.98% 1.52% 1.76% 1.74%
6400 7.75% 2.68% 5.03% 2.58%
Unstructured 100 -7.65% 0.49% -9.88% -0.14%
400 -0.51% 0.32% -1.56% 0.05%1600 0.04% -2.06% -0.09% -0.45%
6400 0.22% 0.27% 0.06% -0.05%
Table 5.2: Comparison of the tradeoff curves, expressed as percentage differences between
the step function integrals of the strong pruning and GW-pruning tradeoff curves. Posi-
tive numbers indicate GW-pruning advantage, negative numbers indicate strong pruning
advantage.
71
Streetmap graphs Multiplier growth factor3 = 1.1 6 = 1.01
County Raw Interpolated Raw Interpolated
Cook IL 2.44% 1.39% 2.43% 1.86%Dallas TX 1.63% 1.50% 1.90% 1.77%Wayne MI 2.47% 2.63% 1.31% 2.63%
King WA -0.06% 1.09% -0.00% 1.14%
Suffolk NY 4.15% 1.98% 1.08% 1.69%
Nassau NY 4.82% -5.97% 4.11% -1.38%Oakland MI 3.65% 1.47% 2.06% 1.41%
Franklin OH 1.78% 1.25% 1.65% 1.43%
Duval FL 4.32% 1.48% 2.99% 1.19%Jefferson KY 1.25% 0.41% 0.79% 0.63%
Montgomery MD 3.63% 1.85% 5.08% 2.18%
San Mateo CA 0.39% -0.53% 0.76% 0.64%
of 2.8%. For 10 of the 12, we had E[ISGy] < E[ISg4], with an average gap of 1.5%. We
get similar gaps for the raw and interpolated curves generated with J = 1.01.
For 8 of the 11 random geometric instances of size 1600, we have E[Sow1 <E[Sip) both
for 6 = 1.1 and 6 = 1.01, with the average gaps shown in the Table 5.2. For the interpolated
tradeoff curves, GW-pruning was better for all 11 instances and both choices of 6. GW-
pruning also outperformed the strong pruning on all 5 of our 6400-vertex geometric graphs,
both before and after interpolation.
However, with smaller geometric and all of unstructured random instances the picture
is less clear. Strong pruning seems to be winning on the raw tradeoff curves for 100- and
400-node random graphs. But GW-pruning seems to get better or comparable results on the
interpolated curves. This can be attributed to the sparsity of the tradeoff curves obtained
for these small instances. Demonstrated in Figure 5-7 is an example of a small random
geometric instance, for which strong pruning provides a better tradeoff curve than does
GW-pruning. The two pruning techniques produced solutions with mostly similar prizes
and edge costs. However the presence of few strong pruning points in a couple of big gaps
results in the strong pruning advantage. Interpolating into these gaps is bound to take that
advantage away.
72
700000400 Node Random Geometric Graph
600000 I-
500000
400000
300000
200000 I-
100000 H*
x GWstrongx
40Per Cent of
60Prize Obtained
Figure 5-7: The sparse tradeoff curves under strong pruning and GW pruning. Note thatstrong pruning provides a better tradeoff curve than does GW-pruning for this instance.This is due to an essentially random point in a big gap.
73
--CD)0
w
+
±
x
xF
0 20
pruningprunin?
+x
80 100
I I
I I
Bibliography
[1] S. Arora and G. Karakostas. A 2+ e approximation algorithm for the k-mst problem.
In 11th Annual ACM-SIAM Symp. on Discrete Algorithms, pages 754-759, 2000.
[2] S. Arya and H. Ramesh. A 2.5 approximation algorithm for the k-mst problem. Infor-
mation Processing Lett., 65:117-118, 1998.
[3] E. Balas. The prize-collecting traveling salesman problem. Networks, 19:621-636, 1989.
[4] J. E. Beasley. Or-library: Distributing test problems by electronic mail. J. Oper. Res.
Soc., 41:1069-1072, 1990. Web page: mscmga.ms. ic. ac.uk/inf o.html.
[5] D. Bienstock, M.X. Goemans, D. Simchi-Levi, and D. Williamson. A note on the prize
collecting traveling salesman problem. Mathematical Programming, 59:413-420, 1993.
[6] A. Blum, R. Ravi, and S. Vempala. A constant factor approximation algorithm for the
k-mst problem. In 28th Annual Symp. on Theory of Computing, pages 442-448, 1996.
[7] S. A. Canuto, C. C. Ribeiro, and M. G. C. Resende. Local search with perturbations
for the prize-collecting steiner tree problem. In Third Metaheuristics Inernational
Conference (Extended Abstracts), pages 115-119, Catholic University of Rio de Janeiro,
1999.
[8] J. Feigenbaum, C. Papapdimitriou, and S. Shenker. Sharing the cost of multicast
transmissions. In 32nd Annual A CM Symp. on Theory of Computing, 2000. To appear.
[9] N. Garg. A 3-approximatiion for the minimum tree spanning k vertices. In 37th Annual
IEEE Symp. on Foundations of Comp. Science, pages 302-309, 1996.
[10] M.X. Goemans and D.P. Williamson. A general approximation technique for con-
strained forest problems. SIAM J. Comput., 24:296-317, 1995.
74
[11] M.X. Goemans and D.P. Williamson. The primal-dual method for approximation
algorithms and its application to network design problems. In D. S. Hochbaum, editor,
Approximation Algorithms for NP-Hard Problems, pages 144-191. PWS Publishing
Company, Boston, 1997.
[12] David S. Johnson, Maria Minkoff, and Steven Phillips. The prize collecting steiner
tree problem: Theory and practice. In 11th Annual ACM-SIAM Symp. on Discrete
Algorithms, pages 760-769, 2000.
[13] A. Lucena and M. G. C. Resende. Strong lower bounds for the prize collecting steiner
problem in graphs. Technical Report 00.3.1, AT&T Labs Research, 2000.
[14] R. Ravi, R. Sundaram, M. Marathe, D. Rosenkrantz, and S. Ravi. Spanning trees short
and small. In 4th Annual A CM-SIAM Symp. on Discrete Algorithms, 1993.
[15] M. G. C. Resende, 1999. Personal communication.
[16] A. Segev. The node-weighted steiner tree problem. Networks, 17:1-17, 1987.
75