A mixed breadth-depth first strategy for
the branch and bound tree of Euclidean kcenter problems
Hatem A. Fayed & Amir F. Atiya
Computational Optimization and
Applications
An International Journal
ISSN 0926-6003
Comput Optim Appl
DOI 10.1007/s10589-012-9503-x
1 23
Your article is protected by copyright and
all rights are held exclusively by Springer
Science+Business Media, LLC. This e-offprint
is for personal use only and shall not be selfarchived in electronic repositories. If you
wish to self-archive your work, please use the
accepted author’s version for posting to your
own website or your institution’s repository.
You may further deposit the accepted author’s
version on a funder’s repository at a funder’s
request, provided it is not made publicly
available until 12 months after publication.
1 23
Author's personal copy
Comput Optim Appl
DOI 10.1007/s10589-012-9503-x
A mixed breadth-depth first strategy for the branch
and bound tree of Euclidean k-center problems
Hatem A. Fayed · Amir F. Atiya
Received: 13 June 2011
© Springer Science+Business Media, LLC 2012
Abstract The k-center problem arises in many applications such as facility location
and data clustering. Typically, it is solved using a branch and bound tree traversed
using the depth first strategy. The reason is its linear space requirement compared
to the exponential space requirement of the breadth first strategy. Although the depth
first strategy gains useful information fast by reaching some leaves early and therefore
assists in pruning the tree, it may lead to exploring too many subtrees before reaching
the optimal solution, resulting in a large search cost. To speed up the arrival to the
optimal solution, a mixed breadth-depth traversing strategy is proposed. The main
idea is to cycle through the nodes of the same level and recursively explore along their
first promising paths until reaching their leaf nodes (solutions). Thus many solutions
with diverse structures are obtained and a good upper bound of the optimal solution
can be achieved by selecting the minimum among them. In addition, we employ
inexpensive lower and upper bounds of the enclosing balls, and this often relieves us
from calling the computationally expensive exact minimum enclosing ball algorithm.
Experimental work shows that the proposed strategy is significantly faster than the
naked branch and bound approach, especially as the number of centers and/or the
required accuracy increases.
Keywords k-Center · Minimum enclosing ball · Branch and bound · Breadth first ·
Depth first
H.A. Fayed () · A.F. Atiya
Faculty of Engineering, Department of Computer Engineering, Cairo University, Giza, Egypt
e-mail: [email protected]
A.F. Atiya
e-mail: [email protected]
Author's personal copy
H.A. Fayed, A.F. Atiya
1 Introduction
The k-center problem deals with covering a set of points with a predetermined number of balls such that the maximum distance between the points of each ball and its
center is minimized. Specifically, it is defined as follows: Given a set of n points
P in Rd and a positive integer k, it is required to cover P by k congruent balls of
the smallest possible size. This problem arises in several applications, primarily in
the facility location problem, where a set of warehouses are to be placed so that the
maximum time to reach any location is minimized (e.g., [10]). Other applications include data clustering (see, e.g., [14, 15]), where a set of points (patterns) are grouped
into similar subsets (clusters). The clustering problem has several application in the
fields of data mining (see, e.g., [9, 13]), information retrieval (see, e.g., [16]), image
segmentation, and image compression (see, e.g., [1]).
The k-center problem, however, poses significant computational challenges. The
simplest k-center problems are known to be NP-Hard, including the Euclidean kcenter problem in the plane [11, 23]. The optimal solution can be found in time
O(k n ) using brute force, which is impractical, even for small k and small n [23].
Many approximation algorithms have been suggested for solving k-center problems
[2, 12]. One of the fastest methods for k-center in 2 and 3 dimensions is developed
in [2]. It uses a dynamic programming approach and achieves a running time that is
1−1/d )
. Later, a greedy algorithm that comupper-bounded by O(n log k) + (k/)O(k
putes a 2-approximation solution was proposed [12]. In this method, at each iteration
i < k, a point that is furthest away from all existing centers is set to be the new center. Another elegant solution to the k-center clustering problem was developed in [3].
This solution is based on the existence of a small subset of the points called core-sets
which result in a polynomial time approximation scheme (PTAS) for fixed k but variable d for Euclidean k-center. A surprising property of the core-sets is that their sizes
are independent of the dimension and the size of P [3]. However, the proposed full
enumeration of all partitions of possible core-sets quickly causes non-computability
in practice, even for moderate approximation errors. A first simple branch-and-bound
(B&B) algorithm traversed using depth first strategy was introduced in [19], and an
improved version of the approximated k-center was presented later in [20]. A similar
algorithm, based on breadth first search strategy, can compute k-center in O(21/ n)
time [4, 18]. Recently the computation of a lower bound at each node of the B&B tree
for the general k-center problem was proposed by relaxing a mixed-integer-convexprogramming formulation [7]. The resulting bound is obtained by solving a convex
problem which successfully pruned the B&B tree substantially and led to smaller
number of nodes and hence saved much time in examining unnecessary nodes. However, in our proposed B&B traversing strategy, described later, we preferred to use
simpler bounds specialized for the Euclidean setting for large problems to obtain a
fast solution.
The k-center problem is a special case of another problem called the k-clustering
problem [2]. In the k-clustering problem a set of n points P in Rd are to be covered by
k shapes or clusters B 1 , . . . , B k . The size of a cluster B j is defined as the maximum
Euclidean distance between a fixed point cj , called the center of the cluster, and
a point of B j . The size of a k-clustering B is the maximum size of a cluster in
Author's personal copy
A mixed breadth-depth first strategy for the k-center branch and bound tree
B. Another related problem is the min-size k-clustering which is similar to the kclustering problem, but with the goal of minimizing the sum of cluster radii. Bilò
et al. [5] show that the problem can be solved in polynomial time when the points
to be clustered are located on a line. For Euclidean spaces of higher dimensions,
they show that the problem is NP-Hard and present polynomial time approximation
methods. Recently Lev-Tov and Peleg [21] gave a polynomial time approximation
approach for the two-dimensional case with linear-cost function.
In this paper, we consider the Euclidean k-center problem for fixed k, and propose
a novel mixed breadth-depth traversing algorithm for the purpose of speeding up the
traversing of the branch and bound tree. In the proposed traversing strategy we cycle
through all nodes of the same level, but from these nodes single out the promising
path, which is recursively explored until reaching the leaf node (solution). Thus, several diverse solutions and therefore tighter bounds are obtained. This leads to pruning
out more branches of the tree and faster convergence. In addition, we employ lower
and upper bounds based on the half-space lemma as already used in [3] which are
computationally very inexpensive. They are also utilized to reduce the number of
relatively expensive minimum enclosing ball algorithm calls, and hence speeding up
the algorithm. Both, the novel traversing scheme and the employed bounds lead to a
considerable improvement in speed.
2 Formulation of the k-center problem and its extensions
Given a set of points P = {pi }, i = 1, 2, . . . , n in Rd , the problem of finding k-balls
(k ≤ n) covering P can be formulated as:
k
1
γ
γ
Min f =
ρj
j =1
s.t.
pi − cj 22
k
≤ ρj 2 + (1 − αij )L
αij = 1
(1)
j =1
αij ∈ {0, 1}
i = 1, 2, . . . , n
j = 1, 2, . . . , k
where αij = 1 indicates that point p i is enclosed by ball B j , whose center and radius
are cj and ρj respectively, γ represents the required cost (γ = ∞ in case of k-center
problem, γ = 1 in case of linear cost and so on), and L is a large value that can be set
as:
L = max pi − p j 22
i,j
(2)
The exhaustive search solution to this formulation necessitates exploring all possible values of α’s and for each set of values, the minimum enclosing ball (MEB)
Author's personal copy
H.A. Fayed, A.F. Atiya
procedure is called for each group of points. The MEB procedure is defined as the
problem of obtaining the center c and radius ρ of the smallest ball that covers the set
of points. The above mixed integer-convex problem is known to be NP-Hard. However, one can exploit certain features of the problem in order to reduce the complexity
and render it more practically from the computational point of view. First, one could
avoid exploring all possible partitions by building a branch and bound tree (see next
section). Second, one can use fast algorithms to compute the MEB procedure which
is a central component of the k-center algorithm (see Sect. 4). Also, a central issue
in the k-center problem is the so-called core-set which approximates MEB for large
problems by considering only the points that are expected to affect the determination
of the center and radius of the ball. These points actually lie on (or close to) the surface of the ball. Thereby, by iteratively adding the furthest non-enclosed point from
the previously estimated ball to the core-set and re-estimating a new ball, we end up
with a ball that encloses all the given points (see Sect. 4). This procedure produces a
significant computational short-cut. A core-set is defined as follows.
Definition 1 Let P be a set of points. Let CS ⊂ P and B = {B 1 , . . . , B k } define the
optimal k-center balls covering CS. CS is called a core-set of P if a (1 + )-expansion
of B covers P . Note that this expansion is obtained by fixing the centers of B and
expanding the radii by a factor of 1 + .
3 A branch and bound approach
A branch and bound algorithm was first introduced for the k-center problem by
Kumar [19]. Kumar’s algorithm starts by covering one point by a ball. Then it incorporates a greedy-like strategy by covering one point at a time (the furthest violator
to the set of balls as defined later). It creates a branch and bound tree, where each
left node corresponds to a solution (an assignment of the points to the available balls,
or rather 0-1 assignments of the αij ’s). Figure 1 illustrates a simple five-point planar
k-center example. It shows the branch and bound tree, where the arrows show the
order of traversing the tree. Leaf nodes mean that all points are assigned to the available balls (corresponding to a complete solution), or else the branch is not explored
further (pruned out) because the solution gives worse objective function than the best
solution so far. Innermost nodes correspond to partial solutions as some points are
not assigned yet or are not enclosed in some ball. At each node, a branch is created
either by adding the point to the core-set of one of the created balls and hence the ball
is re-estimated to cover the new core-set, or by forming a new ball if the number of
created balls is so far less than k. In this way, at most k branches are created. In case
that the number of created balls was less than k, then the branch of forming a new
ball is traversed first. Other branches are traversed in order according to the distance
between the center of the ball to be modified and the considered point. This means
that the closest one is explored first then the second closest and so on (this is why
this procedure is considered a depth first traversing scheme). The algorithm continues until all branches are explored and finally all points are covered. Branches are not
explored further if the achieved solution is worse than the best so far. The obtained
Author's personal copy
A mixed breadth-depth first strategy for the k-center branch and bound tree
j
Fig. 1 Branch and bound tree for Example 1. pi denotes that the point p i is added to the core-set of
ball B j and hence the ball is recomputed to cover the new core-set. Dotted paths indicate nodes that
are pruned out as their solutions would be larger than the solution obtained so-far f ∗ . Numbers between
square brackets represent nodes’ numbers which are made by concatenating the parent node number with
an index
solution will then be the optimal one that leads to the minimum radius. The algorithm
steps are described in Algorithm 1.
Algorithm 1 Recursive Depth First (RDF)
1. f ∗ = ∞, CSj = φ, B j = MEB(CSj ), j = 1, . . . , k
2. k-center(CS,B):
3. p ∗ = the furthest violator to B
4. If p ∗ ∈ (1 + )B then
5.
If (1 + ) maxi ρ(B i ) < f ∗ then f ∗ = (1 + ) maxi ρ(B i )
6.
Return CS, B
7. Else
8.
Sort B in descending order according to their distances from p ∗ (and
hence CS)
9.
For j = 1 to k
10.
If (1 + )ρ(MEB({p ∗ ∪ CSj })) > f ∗ then Continue
11.
CS = CS, B = B, CSj = p ∗ ∪ CSj , B j = MEB(CSj )
12.
ρ({B i }) = maxj =1,...,k ρ({B j }), i = 1, . . . , k
13.
k-center(CS ,B )
14.
End For
15. End If
16. Return the core-sets and balls that lead to the minimum (f ∗ ) obtained
Input to the algorithm are a set of points P and the required accuracy measure
> 0. While the output is a core-set CS ⊂ P consisting of the points selected at
the nodes of the optimal solution, partitioned into k-balls {B 1 , . . . , B k } (the algorithm was proposed in [19, 20] for k-shapes in general, in this paper we focus on
k-balls only). However our proposed traversing scheme can be extended to deal with
Author's personal copy
H.A. Fayed, A.F. Atiya
other shapes as well. During the algorithm, each ball B j ∈ B is the scaled version
of MEB(CSj ) such that the radius of B j , denoted by ρ(B j ), is set to maxi ρ(B i ),
i = 1, . . . , k. The minimum enclosing ball of a null set is defined especially in the implementation to be a ball which does not contain any point and is infinitely far from
any given point. The main loop of the algorithm begins by determining the furthest violator point, p∗ to the set of balls. It is determined as follows. For each non-enclosed
point q, the minimum distance among all distances of q to the centers of the balls is
determined as nnj (q) = minj q − cj 2 where cj , ρj are the center and radius of ball
B j respectively. Then the one that corresponds to the maximum of these minimum
distances is considered as the furthest violator, that is p ∗ = arg maxq∈P \B nnj (q)
or p∗ = arg max q∈P \B minj q − cj 2 . Afterwards, branches are created such that
for each branch, p ∗ is added to one of the core-sets of the current node, CSj , with
precedence from the closest ball to the furthest one. For each created branch, MEB
algorithm is called to replace ball B j by the new ball B j to cover p∗ ∪ CSj . Then all
balls are scaled so that their radii equal to the radius of the largest ball in the new ball
set (this was proposed [20] for an approximate version of k-center which approaches
a good solution faster). Note that when there are more than one null sets, p ∗ is added
only to one null set because there is no difference between the null sets, and adding
p ∗ to any null set will yield the same optimal solution. This presented procedure continues recursively (depth first strategy) until leaf nodes are reached where the furthest
violator is covered by a (1 + )-expansion of the node’s balls B (i.e. each radius is
enlarged by a factor of 1 + ), denoted by (1 + )B; this actually represents an approximate solution to the problem (i.e. we stop exploring the children of this node
as the optimal solution would be at most (1 + ) of the largest radius and we set this
value as an approximate solution for this node). Throughout this scheme the node
that results in the minimum radius is selected as the optimal solution. The detailed
algorithm namely, Recursive Depth First (RDF), is given below.
Example 1 Suppose that it is required to cover the set of points P = {(0, 0), (4, 0),
(2, 3), (2, 0), (2, 1), (3, 0)} by k = 3 balls. The branch and bound tree for the problem
is shown in Fig. 1 and the balls created at each node are shown in Figs. 2 and 3. The
algorithm starts by assigning p1 to ball B 1 (node 1). Then it finds the furthest violator
to B 1 which would be p2 . So we will have two branches either to assign p 2 to a new
ball B 2 (node 11) or to assign it to B 1 (node 12). Exploration of node 11 is performed
first because the furthest point is more likely to be covered with another ball. So at
node 11, we have two balls: B 1 that covers p 1 and B 2 that covers p 2 . Now we find
the furthest violator to B 1 and B 2 as explained before, which would be p 3 . So we
will have three branches either to assign p 3 to a new ball B 3 (node 111), to assign it
to B 1 (node 112) or to assign it to B 2 (node 113). Thus at node 111, we have three
balls: B 1 that covers p 1 , B 2 that covers p 2 and B 3 that covers p3 . Then we find the
furthest violator to B 1 , B 2 and B 3 , which would be p 4 . Note that p 4 is equidistant
from both B 1 and B 2 and further from B 3 , so branches are created and explored in
the following order: assign p 4 to a B 1 (node 1111), assign it to B 2 (node 1112) or
assign it to B 3 (node 1113). So node 1111 is explored first and the MEB procedure is
called to update B 1 to cover p 1 and p 4 . Therefore the new center of B 1 is (1, 0) and
its radius is 1. Then the other balls are scaled correspondingly maintaining their old
Author's personal copy
A mixed breadth-depth first strategy for the k-center branch and bound tree
Fig. 2 Nodes explored using depth first strategy for Example 1
Author's personal copy
H.A. Fayed, A.F. Atiya
Fig. 3 Nodes explored using depth first strategy for Example 1 (continued)
Author's personal copy
A mixed breadth-depth first strategy for the k-center branch and bound tree
centers but setting their radii to 1 (the largest radius of the set of balls) as well (see
Fig. 2d). Then we find the furthest violator to our balls, which would be p5 . Note
that the closest ball to p5 is B 1 while the furthest one is B 2 . So the new branches are
created in the following order: assign p5 to a B 1 (node 11111), assign it to B 3 (node
11112) or assign it to B 2 (node 11113). Exploring node 11111 first and updating B 1
to cover p 1 , p 4 and p 5 . Since all points are covered now, so we have a solution and
f ∗ is set to the new radius of B 1 which would be f ∗ ≈ 1.12. Next, node 11112 is
explored and B 3 is updated to cover p 3 and p 5 (the new radius ρ3 = 1). Since all
points are covered now, so we have another solution and f ∗ is set to the minimum
which would be the radius of the updated ball B 3 which is f ∗ = 1. Then node 11113
is explored and B 2 is updated to cover p 2 and p 5 (the new radius ρ2 ≈ 1.12). Since
ρ2 > f ∗ , this solution is not better than the solution obtained before. Now we have
finished traversing all children of node 1111, then we move to node 1112. At this
node, B 2 is updated to cover p 2 and p 4 (the new radius ρ2 = 1). Since the new
radius ρ2 = f ∗ , then there is no need to explore its children which will not lead to a
better solution f ∗ , so this node can be safely pruned out without affecting the final
optimal solution. We then move on to node 1113 which turned out not to lead to a
better solution as well. Exploration in the same manner continues until all nodes are
traversed (or pruned out).
4 The MEB problem
The minimum enclosing ball that covers a set of a set of m points P in Rd , also
called the 1-center problem, can be formulated in terms of the following quadratic
optimization problem:
Min R
s.t. p i − c22 ≤ R, i = 1, 2, . . . , m
(3)
= r2.
where R
Although there are several algorithms to solve this problem such as the linear time
minimum enclosing circle algorithm [22] and the efficient minimum enclosing ball in
high dimension [17], we employed the predictor-corrector method [24] in conjunction
with core-sets [17] because this approach led to significant speed up, especially for
large data sets compared to other existing methods.
5 Proposed stacked version
To avoid memory overflow due to recursion, we used a stack version of the algorithm,
namely Stacked Depth First (SDF). In this algorithm, node refers to a tree node that
stores the required information which is the ball set B and the core-set CS. In this
implementation, tree nodes are stored/retrieved from a stack in a certain order so as
the more promising solutions are tackled first. First, the root node, with no points
assigned to balls, is stored in the stack (push operation). Throughout the algorithm
the last node in the stack is retrieved (pop operation). Then the furthest violator point
is determined as described before. A new child node is created either by adding the
point to the core-set of one of the created balls and then the ball is re-estimated or
Author's personal copy
H.A. Fayed, A.F. Atiya
by forming a new ball covering the point. Nodes are then stored in the stack in an
ordered way according to the distance between the point and the candidate ball (the
ball that would be enlarged to cover the point in addition to its previous core-set).
That is, the node whose candidate ball is furthest to the point is stored first while the
one whose candidate ball is closest to the point is stored last. In this way the node
whose candidate ball is closest to the point would be traversed first. In case that the
number of the created balls was less than k, the node in which one forms a new ball
covering the point is stored next; this gives precedence to this node to be explored first
in the next step. The algorithm proceeds until the stack becomes empty. Description
of the algorithm steps is given in Algorithm 2.
Algorithm 2 Stacked Depth First (SDF)
1. f ∗ = ∞, CS∗j = φ, B ∗j = MEB(CS∗j ), j = 1, . . . , k
2. root = {CS∗ , B ∗ }
3. Add root to the end of stack
4. Do
5. node = {CS, B} = last element in stack
6. p ∗ = the furthest violator to B
7. If p ∗ ∈ (1 + )B then
8.
If (1 + ) maxi ρ(B i ) < f ∗ then
9.
B ∗ = B, CS∗ = CS, f ∗ = (1 + ) maxi ρ(B i )
10.
End If
11.
Continue
12. Else
13.
Sort B in descending order according to their distances from p∗ (and
hence CS)
14.
For j = 1 to k
15.
If (1 + )ρ(MEB({p ∗ ∪ CSj })) < f ∗ then
16.
Add node to stack with the following changes:
(a) B j replaced by MEB(p∗ ∪ CSj )
(b) CSj replaced by (p∗ ∪ CSj )
(c) All radii are set to the radius of the largest ball
17.
End If
18.
End For
19. End If
20. While stack is not empty
The main loop of the algorithm examines stack and terminates if it is empty. Otherwise it retrieves the last node of stack and determines the furthest violator p ∗ as
defined before. If p ∗ is covered by a (1 + )-expansion of the node’s balls B, i.e.
a new approximate solution is obtained, then the best solution f ∗ is updated if the
new solution is better than the best solution obtained before. On the other hand, if p ∗
is not covered by a (1 + )-expansion of B, then the balls are sorted in descending
order according to the distances from their centers to p ∗ . Branches are created by
Author's personal copy
A mixed breadth-depth first strategy for the k-center branch and bound tree
changing one of the balls of node by adding p ∗ to its core-set and MEB procedure
is called to modify the ball (during this scheme, the radii of all balls and the function
value of the branch child are set to the radius of the largest ball). A child is added
to stack if its function value (the largest radius) is less than the best solution f ∗ . For
early stages, when the number of balls covering points is less than k, we propose that
the first branch is to cover p ∗ by a new ball. This gives the precedence of the furthest violator to be in a new ball first. In practice, this speeds up the algorithm. The
algorithm continues in this manner as long as stack is not empty.
6 Lower and upper bounds
We observed that most of the time elapsed in the above algorithms is due to the
numerous MEB calls. We propose an approach whereby this time can be significantly reduced. This is achieved by developing two computationally inexpensive
lower bounds that can be computed at each branch before calling the expensive MEB
procedure. If any of these lower bounds is greater than the best solution obtained so
far f ∗ , then its subtree can be safely pruned out. We also developed a computationally very simple upper bound. First this upper bound is tested. If it gives a radius that
is smaller than f ∗ , then there is no need to examine the lower bounds and MEB procedure can be called directly. This is advantageous, because one of the lower bounds
is computationally more expensive than this upper bound.
6.1 Lower bounds
According to [3], for the Euclidean setting, any closed half-space that contains the
center of the minimum enclosing ball B j of a set of points CSj must also contain at
least one point from CSj that occurs on the surface of the ball. Therefore, when a ball
B j is going to be modified to cover p ∗ ∪ CSj , a lower bound of the modified ball’s
radius can be estimated by considering the plane perpendicular to the line joining
p ∗ and the center of the ball cj . Then we construct the line joining p ∗ and one
intersection point of this plane with the surface of the ball (note that the ball that is
used here is the ball that is computed using MEB algorithm in an earlier step not the
expanded or scaled one). See Fig. 4(a) for an illustration of this bound. This lower
bound has O(d) complexity for each node. If the above lower bound is less than the
best solution f ∗ and hence cannot rule out the solution branch, then another lower
bound can be examined. It is given by the radius of the ball whose diameter ends
are p ∗ and its furthest point in CSj (see Fig. 4(b)). This lower bound has O(d/)
complexity for each node [3].
6.2 Upper bounds
To avoid extra calculations of lower bounds, a simple upper bound of the modified
ball can be estimated first at each branch. If this upper bound is less than the best
solution f ∗ , then there is no need to check lower bounds and call MEB procedure
directly. This will provide some computational savings because the second lower
Author's personal copy
H.A. Fayed, A.F. Atiya
Fig. 4 Lower and upper bounds
for a modified ball
bound is computationally more expensive than the upper bound. The proposed upper
bound is the radius of the ball whose diameter ends are p ∗ and its furthest point in
the unexpanded old ball (see Fig. 4(c)). This upper bound has O(d) complexity for
each node and can avoid calling to the second lower bound which is more expensive.
7 Mixed breadth-depth traversing
As mentioned before, invoking computationally inexpensive lower bounds can effectively save time by avoiding unnecessarily expensive MEB calls. One can note that
Author's personal copy
A mixed breadth-depth first strategy for the k-center branch and bound tree
approaching the optimal solution early in the search can lead to a beneficial short-cut
in the computation time. Thus, as an attempt to reduce the average time of reaching
the optimal solution, a mixed breadth-depth traversing scheme is proposed. The idea
of this approach is to cycle through the nodes of the same level and traverse their subtrees along the first promising path (depth first) until reaching leaf nodes (solutions).
Throughout this procedure the best solution f ∗ is updated and used more effectively,
along with the lower bounds to truncate futile branches.
The proposed procedure is accomplished by modifying SDF algorithm to generate
several stacks. At any node, branches are explored in the same way as before, however only the first generated branch is appended in the current stack, while the other
branches are used to form a new stack. Exploration of a stack continues recursively
until a leaf node (solution) is reached. Then we move on to explore the following
stack. In this way, for nodes of the same level, paths are traversed in the following
order. The first promising path of the first node, the first promising path of the second
node, . . . , the first promising path of the last node, the second promising path of the
first node, the second promising path of the second node, . . . , the last promising path
of the last node. This is made by cycling through all generated stacks until reaching a
leaf node. This process continues until all nodes in all stacks are explored and stacks
become empty.
The first two steps of the algorithm are the same as those of SDF. An index of
the first stack used is initialized as id = 1. The main loop of the algorithm examines
the cardinality of all stacks and terminates if they are all empty. If the current stack,
stackid , is not empty, then the last node is retrieved and exploration of its branches
recursively continues as described above. Otherwise, the current stack index, id, is
set to the index of the first non-empty stack found starting from id + 1 and cycle to
id − 1 and its last node is retrieved. The algorithm proceeds as before by determining the furthest violator p ∗ . If p ∗ is covered by a (1 + )-expansion of the node’s
balls B, i.e. a new solution is obtained, then the best solution is updated if the new
solution is better than the best solution obtained before. Whenever a leaf node (solution) is reached, we stop exploring the current stack and cycle to the next non-empty
stack. In the case of no branches are created, this occurs when lower bounds truncate all created branches, the algorithm stops exploring the current stack and cycle
to the next non-empty stack. The algorithm continues until all created stacks become
empty. Steps of the algorithm namely, Mixed Stacked Breadth-depth First (MSBDF),
is given in Algorithm 3.
Example 2 To illustrate the proposed traversing scheme, assume that the branch and
bound tree for a certain problem of covering a set of 4 points by k = 3 balls is shown
in Fig. 5. The algorithm starts by creating a stack (stack1 ) containing one node which
will assign the point p 1 to ball B 1 . Then the furthest violator is found and suppose
it is p 2 . So we will have two branches: either to assign p 2 to ball B 2 or to assign
it to ball B 1 . Instead of adding these branches to the same stack (stack1 ), we only
append the first branch to the same stack and create a new stack (stack2 ) to store
the other branch. We then continue retrieving nodes from the current stack (stack1 )
as long as we didn’t reach a leaf node (a solution). Now, at node 11, we have two
balls: B 1 covering p 1 and B 2 covering p 2 . Then the furthest violator is obtained,
Author's personal copy
H.A. Fayed, A.F. Atiya
Algorithm 3 Mixed Stacked Breadth-Depth First (MSBDF)
1. id = 1, Nstacks = 0, f ∗ = ∞, CS∗j = φ, B ∗j = MEB(CS∗j ), j = 1, . . . , k
2. root = {CS∗ , B ∗ }
3. Add root to the end of stackid
4. Do
5. If stackid is empty then id = index of the first following non-empty stack
6. node = {CS, B} = last element in stackid
7. p ∗ = the furthest violator to B
8. If p ∗ ∈ (1 + )B then
9.
If (1 + ) maxi ρ(B i ) < f ∗ then
10.
B ∗ = B, CS∗ = CS, f ∗ = (1 + ) maxi ρ(B i )
11.
id = index of the first following non-empty stack
12.
End If
13.
Continue
14. Else
15.
Sort B in descending order according to their distances from p∗ (and
hence CS)
16.
Branches = 0
17.
For j = 1 to k
18.
If (1 + )ρ(MEB({p ∗ ∪ CSj })) < f ∗ then
19.
Branches = Branches + 1
20.
If this is the first promising path then
21.
Add node to stackid with the following changes:
(a) B j replaced by MEB(p ∗ ∪ CSj )
(b) CSj replaced by (p ∗ ∪ CSj )
(c) All radii are set to the radius of the largest ball
22.
Else
23.
Nstacks = Nstacks + 1
24.
Add node to stackNstacks with the following changes:
(a) B j replaced by MEB(p ∗ ∪ CSj )
(b) CSj replaced by (p ∗ ∪ CSj )
(c) All radii are set to the radius of the largest ball
25.
End If
26.
End If
27.
End For
28. End If
29. If Branches = 0 then id = index of the first following non-empty stack
30. While stacks are not empty
which is supposed to be p 3 , and new branches are created as follows: assign p 3 to
a new ball B 3 , assign it to B 2 or assign it to B 1 . Only the first branch is appended
to the current stack (stack1 ) while another stack (stack3 ) is created to store the other
branches in a descending order based on the distance between the candidate ball (the
ball to be enlarged) of the branch and the furthest violator point; i.e. that is the branch
corresponding to the largest distance is appended first while the branch corresponding
Author's personal copy
A mixed breadth-depth first strategy for the k-center branch and bound tree
Fig. 5 A sample of a
constructed branch and bound
tree to cover 4 points by k = 3
balls. Numbers between round
brackets denote the order of the
solutions obtained using
MSBDF
to the smallest distance is appended last. Exploration continues in this manner; that
is at each node, only the most promising branch (either the branch corresponding to
creating a new ball or the one whose candidate ball is closer to the furthest violator)
is appended to the current stack and a new stack is created to store the other branches.
Author's personal copy
H.A. Fayed, A.F. Atiya
Fig. 6 Stacks generated for the branch and bound tree in Fig. 5. Processing stack has a bold border. Leaf
nodes (solutions) are shaded
We keep exploring the current stack (stack1 ) until we reach a leaf node (a solution)
which is Node 1111 (see Figs. 5 and 6) at iteration 4, then we move on to the next
stack (stack2 ). The same procedure is applied to stack2 until we reach a leaf node
which is Node 1121 at iteration 6 and so on. Note that we cycle through the end
nodes of the stacks, then go back and tackle the next layer of nodes in the stacks, and
so on till visiting all nodes. See Figs. 6 and 7 for illustration.
Author's personal copy
A mixed breadth-depth first strategy for the k-center branch and bound tree
Fig. 7 Stacks generated for the branch and bound tree in Fig. 5 (continued). Processing stack has a bold
border. Leaf nodes (solutions) are shaded
8 Experimental results
The experimental work compares several variants of the k-center algorithms: SDF
which is based on Kumar’s algorithm, but with the stacked implementation discussed
in Sect. 5, SDFB which is SDF with lower/upper bounds and MSBDFB which is the
proposed MSBDF algorithm with lower/upper bounds. The breadth first algorithm
[4, 18] clustering has a running time of O(21/ n) which is impractical if < 0.01.
So we did not investigate it for our data sets, because we used smaller values of and because the size of the core-sets obtained were in the range from 20 to 50. Although Brandenberg and Roth [7] proposed a lower bound that efficiently reduces the
number of B&B tree nodes, we preferred to use the simple bounds presented in this
Author's personal copy
H.A. Fayed, A.F. Atiya
Table 1 Experimental data sets
Data set
Dimension
Number of points
Cat
3
352
Shark
3
1744
Seashell
3
18033
Bunny
3
35947
Dragon
3
437645
Egypt
2
7146
USA
2
13509
Germany
2
15112
Italy
2
16862
China
2
71009
World
2
1904711
Pen1
16
779
article based on [3] for large data set to find a fast solution. Experiments include several data sets used in clustering and facility location problems. The MEB algorithm
is implemented using the predictor-corrector method proposed [24] in conjunction
with core-sets suggested [17]. We used MATLAB 7.1 on Windows XP with SP2 running on Pentium 2.4 GHz PC with 2 GB RAM. We used the following performance
measures:
1.
2.
3.
4.
f ∗ : the optimal function value (the maximum radius among all k-balls).
N : the number of computed nodes.
t∗ : the elapsed CPU time until reaching the optimal function value.
T : the total elapsed CPU time of the algorithm.
8.1 Data sets
The 3D data sets are those used in [7, 20] which can be found at http://www.ocnus.
com/models/. Solutions of these problems are very useful in data mining. The 16D
data set (Pen1) is the training set for digit “1” of the Pen database obtained from UCI
Machine Learning Repository [6]. The 2D data sets were obtained from TSPLIB
library [8, 25]. They represent cities/locations in different countries. Solutions of
these problems are very useful in facility location problems where the objective is
to minimize the maximum time to reach any location. Names of data sets and their
corresponding dimension and number of points are shown in Table 1.
9 Discussion of the results
Comprehensive results are shown in Tables 2, 3 and 4 for = 10−2 , = 10−3 and =
10−4 respectively. The effectiveness of the lower and upper bounds can be observed
from the number of computed nodes of SDFB which is significantly smaller than
that of SDF for all data sets. This leads to reduction in both the elapsed CPU time
8
5
6
Egypt
USA
7
Egypt
USA
5
6
Egypt
Egypt
3
4
Dragon
5
Bunny
Dragon
3
4
Bunny
5
Seashell
Bunny
3
4
Seashell
Seashell
7
8
Cat
Cat
5
6
Cat
Cat
3
4
Cat
Cat
k
Data set
0.068
0.061
0.066
0.051
0.056
0.066
0.549
0.607
0.697
0.042
0.045
0.048
0.052
0.058
91950.863
100486.74
1722.14
1848.183
2073.792
2363.673
f∗
Table 2 Results for = 10−2
504
14576
65750
3133
152026
10328
2697
495
3650
333
447320
68570
318
232510
7646
546
1109381
367506
61819
18556
1112
33933
2738
895
216
1772
178
207514
35960
187
87987
3658
298
252421
97838
18473
5148
773
258
4856
1070
24961
2459
891
373
2383
193
45592
28868
242
76765
3688
313
108528
51401
18022
4998
926
190
86.08
3.57
71.39
55.03
2.45
40.39
5.45
1.97
8.48
0.59
3.11
88.41
15.28
857.66
10.98
2.14
29.77
5.3
1.67
0.95
130.05
16.23
161.14
1.83
106.75
1.53
136.52
12.03
150.14
161.19
11.91
1
48.75
0.88
31.53
317.53
23.38
6.75
1.67
0.48
MSBDFB
115
25.13
9
1.2
0.75
SDFB
0.75
92.3
16.02
1070.53
173.89
1.5
236.61
16.5
1.06
732.06
238.38
44.02
15.2
1.92
0.89
SDF
1853
t∗
MSBDFB
SDF
SDFB
N
T
86.09
5.22
155.66
11.84
3.56
1.02
105.38
17.94
1158.77
203.55
1.7
448.5
16.8
1.61
1107.7
379.95
65.38
17.08
2.44
0.97
SDF
55.06
4.44
84.13
7.09
2.25
0.75
100.41
17.13
925.55
175.67
1.75
311.03
12.16
1.33
468.02
180.92
35.81
10.06
1.64
0.81
SDFB
14.77
3.69
61.36
6.44
2.22
1.09
141.14
18.41
236.55
141.28
2.05
278.61
13.03
1.42
194.08
89.98
32.59
9.48
2.05
0.53
MSBDFB
Author's personal copy
A mixed breadth-depth first strategy for the k-center branch and bound tree
6
7
8
Pen1
Pen1
5
Pen1
Pen1
5
6
World
World
7
8
6
China
China
5
China
China
7
8
Italy
Italy
5
6
Italy
Italy
7
8
Germany
Germany
5
6
Germany
Germany
7
8
USA
USA
k
Data set
Table 2 (Continued)
75.357
79.978
83.789
89.448
62.549
72.218
7900.747
9114.077
9749.977
10670.507
1880.486
1984.573
2248.179
2746.525
1551.994
1647.17
1798.07
2071.562
75836.194
79917.169
f∗
49597
2328764
326037
314165
78985
29309
2277
755797
691460
15055
4462
320762
16695
4161
5681
583112
107108
133928
38090
8407
824
164305
188335
4198
1546
72252
4665
1251
2064
226627
1930252
936011
73131
7953
326395
8535151
233393
21566
1569651
202224
58.39
13.28
73848
212313
100623
33282
18801
5161
729
97306
2225.94
177.89
347.25
72.28
1634.45
148.97
1325.95
1796.48
22.38
1492
5076
244.13
20.39
1.75
6.11
8381.67
981.77
179.31
32.11
409.98
28686
1712
1743
2264
698007
121216
39447
7376
310556
50455
SDF
MSBDFB
SDF
SDFB
t∗
N
883.98
110.72
222.52
50.28
162.83
103.81
28.41
21.13
140.36
1184.38
145.95
920.98
734.77
38.92
15.13
15.17
4.69
4.58
6.56
1202
404.56
25.39
22.52
212.57
54.88
MSBDFB
1408.00
1280.84
1960.83
17.47
12.31
147.75
12.42
1.36
4.67
5004.66
617
122.33
23.19
225.17
32.86
SDFB
T
2576.42
354.64
413.11
95.13
2075.44
362.72
2087.69
1965.77
62.55
21.31
377.53
23.73
6.89
9.53
10623.94
1221.91
331.34
35.28
1828.58
243.2
SDF
1039.05
192.27
259.84
64.66
1859.41
351.70
1954.38
2131.14
50.77
19.5
221.38
14.44
4.53
7.08
6356.22
768.53
226.61
25.55
1005.09
142.66
SDFB
326.63
166.06
55.92
29.73
1450.63
304.84
1302.2
770.64
62.98
18.75
90.61
6.45
7.08
7.59
2431.48
424.86
132.28
23.72
977.31
148.56
MSBDFB
Author's personal copy
H.A. Fayed, A.F. Atiya
8
5
6
Egypt
USA
7
Egypt
USA
5
6
Egypt
Egypt
3
4
Dragon
5
Bunny
Dragon
3
4
Bunny
5
Seashell
Bunny
3
4
Seashell
Seashell
7
8
Cat
Cat
5
6
Cat
Cat
3
4
Cat
Cat
k
Data set
0.067
0.06
0.065
0.051
0.056
0.065
0.547
0.606
0.695
0.042
0.045
0.047
0.051
0.057
91341.402
100036.8
1714.429
1839.908
2060.002
2353.089
f∗
Table 3 Results for = 10−3
708
16196
205102
3293
210640
11511
7119
940
10286
996
889780
117550
903
525576
12774
816
1201821
328600
69988
59432
1171
47387
3141
2038
382
5296
540
424104
63635
607
214175
6194
447
270968
87468
21392
5632
873
1246
19699
1245
32451
2895
1918
386
3615
388
80457
52844
290
149320
5499
473
128840
60416
18894
5117
1018
311
220.11
2.5
185.5
9.16
1.44
1.23
243.22
38.53
2110.36
125.52
3.75
377.52
7.91
0.78
849.19
174.81
49.23
13.42
2.48
1.34
SDF
1981
t∗
MSBDFB
SDF
SDFB
N
1.19
146.22
2.13
103.84
40.48
2.95
39.92
5.64
0.81
6.34
0.92
0.95
187.44
29.08
260.25
0.91
236.06
37.39
1767.42
2.16
56.55
3.28
117.84
5.52
111.63
284.19
6.42
0.72
38.95
111.47
86.31
16.27
5.72
1.67
0.69
MSBDFB
374.14
27
8.14
1.38
5.09
SDFB
1.42
2.97
251.84
5.61
211.89
13.44
8.69
1.48
250.97
39.72
2268.56
344.05
4.5
995.56
26.44
2.13
1156.03
335
72.92
18.06
SDF
T
168.56
4.48
119.31
8.95
4.84
1.09
243.81
38.63
1897.14
309.3
3.97
750.16
21.42
1.98
506.53
164.75
39.66
10.97
1.72
5.19
SDFB
55
4.56
81.33
7.2
4.63
1.16
193.38
29.09
407.2
257.22
2.41
530.34
19.36
2.09
231.52
105.09
34.05
9.52
2.17
0.78
MSBDFB
Author's personal copy
A mixed breadth-depth first strategy for the k-center branch and bound tree
6
7
8
Pen1
Pen1
5
Pen1
Pen1
5
6
World
World
7
8
6
China
China
5
China
China
7
8
Italy
Italy
5
6
Italy
Italy
7
8
Germany
Germany
5
6
Germany
Germany
7
8
USA
USA
k
Data set
Table 3 (Continued)
75.020
79.166
83.414
89.048
62.148
71.509
7886.225
9092.566
9709.513
10649.047
1863.385
1972.533
2240.114
2734.098
1546.969
1646.393
1793.488
2062.081
75567.021
79598.058
f∗
85673
2737508
432675
328979
85435
46049
2987
1976967
1244335
24955
13422
532354
27090
12615
12086
827571
156441
147275
43333
12992
1039
430024
328708
7284
4376
127508
6928
3762
4049
650965
4274453
2726463
137375
8526
687142
18644224
454565
23546
3341705
338535
94.69
17.56
122194
233839
111536
34868
21816
6412
958
260957
2761.45
350.58
366.66
83.25
2856.86
272.14
2668.69
3283.88
24.89
4280
8725
415.81
30.03
2.92
13.03
17435.16
2881.8
576.53
23.36
555.7
42890
1834
3993
3979
1345387
422342
65222
7460
623047
74549
SDF
MSBDFB
SDF
SDFB
t∗
N
1361.19
205.11
247.11
56.00
170.16
135.41
29.22
23.77
208.80
1510.28
215.27
484.42
748.28
52.7
15.21
16.16
5.83
4.88
8.97
3566.75
1369.17
73.22
12.27
134.3
49.78
MSBDFB
2687.91
2118.89
2698.89
22.09
16.17
264.03
20.16
2.42
9.45
10426.64
1824.83
394.02
18.64
315.03
59.34
SDFB
T
3150.55
486.84
432.52
107.77
3524.77
529.44
5187.39
3509.81
91.42
52.02
616.09
33.88
17.8
17.7
23088.78
3482.8
633.67
38.34
3760.88
401.41
SDF
1548.41
276.25
284.27
71.95
3225.59
434.25
4113.17
2883.92
80.22
45.86
382.73
22.63
12.94
12.91
13755
2209.83
432.52
29.55
2102.63
247.48
SDFB
340.84
177.64
56.84
33.14
1750.14
403.11
2649
1140.97
95.84
44.95
150.16
7.63
13.66
12.73
4673.95
1442.69
212.42
25.02
1948.5
223.81
MSBDFB
Author's personal copy
H.A. Fayed, A.F. Atiya
5
6
7
8
5
6
Egypt
Egypt
Egypt
Egypt
USA
USA
5
Bunny
3
4
Bunny
4
3
Bunny
Dragon
5
Seashell
Dragon
3
4
8
Cat
Seashell
7
Cat
Seashell
5
6
Cat
Cat
3
4
Cat
Cat
k
Data set
0.067
0.06
0.065
0.051
0.056
0.065
0.547
0.605
0.694
0.042
0.044
0.047
0.051
0.057
91310.62
99991.802
1713.657
1839.08
2057.224
2352.031
f∗
Table 4 Results for = 10−4
714
206206
3323
213536
13226
7077
940
24922
1224
937870
126230
987
527826
12846
825
1230565
327858
70354
16291
1985
59587
1179
48114
3540
1983
382
10363
672
448093
68234
652
215265
6225
453
278682
88322
21553
5673
876
368
22191
1305
33044
2787
1858
386
9071
434
90838
54613
308
149880
5390
479
130920
60621
19206
5087
1123
211
217.72
2.78
124.86
11.47
1.52
1.27
520.91
47.72
2291.16
141.2
3.45
383.94
8.28
0.89
889.05
176.47
50.06
13.83
1.98
1.41
SDF
MSBDFB
SDF
SDFB
t∗
N
135.86
2.11
69.67
6.69
1
0.92
369.27
46.92
1833.58
123.78
3.42
282.58
6.78
0.73
387.16
88.31
27.23
8.33
1.56
1.38
SDFB
24.14
3.08
48.39
5.66
0.8
0.97
326.64
21.97
282.88
57.28
2.31
116.31
4.61
1.17
112.39
39.3
16.63
5.56
2.5
0.8
MSBDFB
1.5
2.5
259.2
5.97
218.75
14.95
8.16
1.5
547.38
47.98
2480.58
369.91
4.09
1008.59
27.05
2.36
1210.2
334.36
73.89
18.55
SDF
T
162
4.56
119.31
8.58
4.86
1.08
552.53
47.19
1988.7
326.89
4.09
746.63
21.78
1.91
522.06
162.94
39.67
11.16
1.86
1.47
SDFB
60.59
4.7
82.16
6.97
4.5
1.11
498.3
31.52
452.75
264.2
2.55
530.45
17.81
1.95
232.7
104.61
34.47
9.45
3.09
0.84
MSBDFB
Author's personal copy
A mixed breadth-depth first strategy for the k-center branch and bound tree
6
7
8
Pen1
Pen1
5
Pen1
Pen1
5
6
World
World
7
8
6
China
China
5
China
China
7
8
Italy
Italy
5
6
Italy
Italy
7
8
Germany
Germany
5
6
Germany
Germany
7
8
USA
USA
k
Data set
f∗
74.986
79.131
83.376
89.008
62.120
71.413
7882.678
9082.587
9705.146
10642.815
1860.872
1970.921
2239.106
2732.816
1546.273
1645.652
1792.681
2061.153
75533.032
79566.786
Table 4 (Continued)
90108
2887553
444904
352373
86410
46271
3007
6384759
1172515
25915
14357
514546
26887
12711
12036
875990
161582
157202
44021
13079
1039
1391137
309184
7551
4555
128805
6860
3835
4025
680141
4579321
2835642
151718
8431
711633
19838696
498737
23146
3428965
355958
82.41
26.72
109147
2893.83
237258
112814
35067
22361
3214.39
358.95
436.73
92.86
248.31
2478.36
950
14425.3
6524
264801
25.23
4481
9086
433.31
31.88
3.3
9.66
18123.13
1543.64
410.42
23.34
560.8
36301
1822
4045
3941
1400799
434155
67474
7518
642666
80058
SDF
MSBDFB
SDF
SDFB
t∗
N
1537.84
242.83
292.13
63.59
2416.83
242.20
11069.28
2397.31
22.28
24.05
269.8
20.38
2.66
6.95
10624.8
948.11
283.94
17.3
317.34
50.25
SDFB
177.70
155.58
32.45
24.09
1493.52
230.45
500.13
569.92
53.78
23.85
16.63
5.09
4.77
6.72
561.91
174.06
29.66
12.44
129.45
49.7
MSBDFB
T
3636.27
498.89
509.58
121.33
2986.22
496.42
17028.11
3294.44
95.08
55.17
596
34.97
18.44
18.06
25356.78
3748.19
692.11
38.36
3908.66
424.53
SDF
1725.56
320.59
335.84
82.31
2909.33
480.36
13097.55
2733.73
82.16
48.45
360.59
22.27
12.83
12.84
14865.63
2288.55
473.78
28.31
2163.02
258.72
SDFB
377.05
205.19
62.34
34.27
1726.27
467.55
2703.38
1031.53
100.11
48.02
123.86
6.91
13.28
12.48
4933.91
1484.05
221.05
25.47
2013.36
235.41
MSBDFB
Author's personal copy
H.A. Fayed, A.F. Atiya
Author's personal copy
A mixed breadth-depth first strategy for the k-center branch and bound tree
Fig. 8 Trace of the updated optimal function value versus time for = 10−4
Author's personal copy
H.A. Fayed, A.F. Atiya
Fig. 9 Trace of the updated optimal function value versus time for = 10−4
Author's personal copy
A mixed breadth-depth first strategy for the k-center branch and bound tree
Fig. 10 Results of k-center for = 10−4
until reaching the optimal solution value and the total elapsed CPU time of SDFB
compared to SDF. Regarding MSBDF, it becomes the indisputable best when the
number of balls and/or the accuracy increases. This can be observed clearly from
Author's personal copy
H.A. Fayed, A.F. Atiya
Figs. 8 and 9 where the updated optimal function value is traced with time throughout
each algorithm. The reason for this is that lower bounds truncate many nodes and
lead to a smaller number of computed nodes compared to both SDF and SDFB.
This edge does not appear in many cases when the optimal solution is close to the
first depth path or the number of balls is small. In these cases, cycling represents an
overhead and causes extra exploration of subtrees which in turn delays reaching the
optimal solution. It can be concluded that the average elapsed CPU time of MSBDF
is generally better than that of SDFB. However SDFB in some problems can reach
the optimal solution more rapidly. Solution of some k-center problems with = 10−4
is shown in Fig. 10.
10 Conclusions
In this paper, a novel mixed breadth-depth traversing algorithm is proposed for the
purpose of speeding up the traversing of the k-center branch and bound tree. In addition some computationally inexpensive lower and upper bounds are employed to
reduce the number of relatively expensive MEB calls and hence speeding up the algorithm. According to the results attained on several clustering and facility location
problems, we can observe that the average time to reach the optimal solution was
considerably decreased especially when either the number of balls or accuracy go up.
As an extension to this work, MSBDF algorithm and the employed lower and upper
bounds can easily be modified to handle the general k-clustering problem.
Acknowledgements
experiments.
We would like to thank René Brandenberg for providing several data sets for the
References
1. Acharya, T., Ray, A.K.: Image Processing: Principles and Applications. Wiley, New York (2005)
2. Agarwal, P.K., Procopiuc, C.M.: Exact and approximation algorithms for clustering. In: Proc. 9th
ACM-SIAM Symposium on Discrete Algorithms, pp. 658–667 (1998)
3. Bǎdoiu, M., Har-Peled, S., Indyk, P.: Approximate clustering via core-sets. In: Proc. 34th Annual
ACM Symposium on Theory of computing (STOC’2002), pp. 250–257 (2002)
4. Bǎdoiu, M., Clarkson, K.L.: Smaller core-sets for balls. In: Proc. 14th Annual ACM-SIAM Symposium on Discrete Algorithms, pp. 801–802 (2003)
5. Bilò, V., Caragiannis, I., Kaklamanis, C., Kanellopoulos, P.: Geometric clustering to minimize the sum
of cluster sizes. In: Proc. of the European Symposium on Algorithms. LNCS, vol. 3669, pp. 460–471
(2005)
6. Blake, C.L., Merz, C.J.: UCI repository of machine learning databases. Dept. Inf. Comput. Sci., Univ.
California, Tech. Rep. (1998). http://archive.ics.uci.edu/ml/datasets
7. Brandenberg, R., Roth, L.: New algorithms for k-center and extensions. J. Comb. Optim. 18, 376–392
(2009)
8. Cook, W.J.: National traveling salesman problems. http://www.tsp.gatech.edu/world/countries.html
9. Duda, R.O., Hart, P.E., Stork, D.G.: Pattern Classification, 2nd edn. Wiley, New York (2001)
10. Farahani, R.Z., Hekmatfar, M.: Facility Location: Concepts, Models, Algorithms and Case Studies.
Physica-Verlag, Heidelberg (2009)
11. Fowler, R.J., Paterson, M.S., Tanimoto, S.L.: Optimal packing and covering in the plane are NPcomplete. Inf. Process. Lett. 12, 133–137 (1981)
12. Gonzalez, T.F.: Clustering to minimize the maximum intercluster distance. Theor. Comput. Sci. 38,
293–306 (1985)
Author's personal copy
A mixed breadth-depth first strategy for the k-center branch and bound tree
13. Hastie, T., Tibshirani, R., Friedman, J.H.: The Elements of Statistical Learning: Data Mining Inference, and Prediction. Springer, Berlin (2001)
14. Jain, A.K., Dubes, R.C.: Algorithms for Clustering Data. Prentice Hall, New York (1988)
15. Jain, A.K., Murthy, M.N., Flynn, P.J.: Data clustering: a review. ACM Comput. Rev. 31(3), 264–323
(1999)
16. Kowalski, G.: Information Retrieval Architecture and Algorithms. Springer, Berlin (2010)
17. Kumar, P., Mitchell, J.S.B., Yildirim, A.: Computing core-sets and approximate smallest enclosing
HyperSpheres in high dimensions. In: Proc. 5th Workshop on Algorithm Engineering and Experiments, pp. 45–55. SIAM, Philadelphia (2003)
18. Kumar, P., Mitchell, J.S.B., Yildirim, A.: Approximate minimum enclosing balls in high dimensions
using core-sets. ACM J. Exp. Algorithmics 8, 1–29 (2003)
19. Kumar, P.: Clustering and reconstructing large data sets. PhD thesis, Department of Computer Science, Stony Brook University (2004)
20. Kumar, P., Kumar, P.: Almost optimal solutions to k-clustering problems. Int. J. Comput. Geom. Appl.
20(4), 431–447 (2010)
21. Lev-Tov, N., Peleg, D.: Polynomial time approximation schemes for base station coverage with minimum total radii. Comput. Netw. 47, 489–501 (2005)
22. Megiddo, N.: Linear-time algorithms for linear programming in R 3 and related problems. SIAM J.
Comput. 13, 759–776 (1983)
23. Megiddo, N., Supowit, K.J.: On the complexity of some common geometric location problems. SIAM
J. Comput. 13, 182–196 (1984)
24. Mehrotra, S.: On the implementation of a primal-dual interior point method. SIAM J. Optim. 2(4),
575–601 (1992)
25. Reinelt, G.: TSPLIB, a traveling salesman problem library. ORSA J. Comput. http://comopt.ifi.
uni-heidelberg.de/software/TSPLIB95