1. Efficient Algorithms for the Weighted k-Center Problem on a Real Line
Danny Z. Chen and Haitao Wang
Computer Science and Engineering
University of Notre Dame
Indiana, USA

2. Problem definition
Given a set of points/customers P={p1…pn } on a real line L, each point pi has a positive weight w(pi)
Find k centers/facilities {f1…fk} on L for a given integer k to serve all customers to minimize the maximum service distance
Service distance between a center f and its served point pi: w(pi)*|pi-f| f1 f2 f3 L p1 pn
determine k=3 centers to serve all customers
Non-weighted case: All customers in P have the same weight

3. Previous work Most k-center problem variants are NP-hard
Non-weighted case on a tree
O(n) time, Frederickson 91’
Weighted case on a tree: O(nlog2n) time
O(nlog2nloglogn) time Megiddo and Tamir 83’
Cole’s parametric search, 87’
Weighted case on a real line:
Time linear in n and exponential in k, Bhattacharya and Shi 07’

4. Our results
Reduce the k-center problem to a points approximation problem
Utilizes algorithms for the points approximation problem, Chen and Wang 09’
Develop new data structures for answering a 2-D sublist LP queries
Our algorithms:
O(nlog1.5n) time, O(nlogn + klog4n) time
Improving the O(nlog2n) time result on a tree

5. More stories Our new result on the k-center problem: O(nlogn) time
The points approximation problem
O(nlog2n) time, Chen and Wang 09’
O(nlog n) time, Fournier and Vigneron, in arXiv, September 2011
The k-center problem is also solvable in O(nlogn) time
Better than our result (O(nlog1.5n),O(nlogn + klog4n))
Drawback: The algorithm uses Cole’s parametric search
Complicated and difficult to implement
Large constant hidden in the big-O
Mainly of theoretical interest
Our new result on the k-center problem: O(nlogn) time
Our algorithm is favorable for the following reasons:
No parametric search involved and practical
More efficient data structures for 2-D sublist LP queries
O(n+k2log3nloglogn) time when all points are sorted on L and all point weights are also sorted
Applicable to the discrete version

6. Our algorithm Reduce the problem to a points approximation problem
Use the algorithmic schemes for the points approximation problem
Need a data structure for 2-D sublist LP queries
New data structures for 2-D sublist LP queries

7. A sub-problem: the 1-center problem queries
Given a query q(i,j) with i≤j, we want to solve the 1-center problem on all customers in P from pi to pj
Return the optimal value pj pi
Reduce the 1-center queries to 2-D sublist LP queries

8. 2-D Sublist LP Queries Given: an upper halfplane set H={hi | 1≤i≤n}
Query q(i,j): the lowest point in the common intersection of the half-planes in Hij={hi,hi+1…hj}
common intersection
lowest point

9. The x-intercept ordered property of H
The upper halfplane set H={hi | 1≤i≤n}
The intersections of the bounding lines of H with the x-axis are ordered in the same order as the halfplanes in H h4 h3 h2 x h1 h5

10. Previous work on the 2-D sublist queries
construction time
query time
O(nlogn)
O(log4n)
Guha and Shim, 07’
O(log2n)
Chen and Wang, 09’
O(nlog2n)
O(logn)
in the paper
O(nlog1.5n)
O(log1.5n)
this talk

11. Previous work on the 2-D sublist queries
construction time
query time
O(nlogn)
O(log4n)
Guha and Shim, 07’
O(log2n)
Chen and Wang, 09’
O(nlog2n)
O(logn)
in the paper
O(nlog1.5n)
O(log1.5n)
this talk
The x-intercept ordered property is needed for the last two results.

12. 2-D Sublist LP Queries Given: An upper halfplane set H={hi | 1≤i≤n}
Query q(i,j): The lowest point in the common intersection of Hij={hi, …, hj}
common intersection
lowest point p*

13. Our approach
Reduce the computing of the lowest point p* to computing the sub-path convex hull of a simple path

14. The sub-path convex hull queries
Given a simple path with vertices v1,v2…vn along the path
Each query q(i,j) specifies a sub-path beginning at vi and ending at vj
Return the convex hull of the sub-path
The convex hull can be implicitly represented in a way that support the standard binary-search-based operations v5 v4 v7 v6 v3 v9 v8 v2 v1
q(2,8)
A data structure of construction time O(nlogn) and query time of O(logn)
Compact interval trees, Guibas, Hershberger, and Snoeyink, 91’

15. The reduction from computing p* to computing the subpath convex hull
By duality!
The boundary of the common intersection is the upper envelop of the arrangement of the bounding lines
Corresponds to the lower hull of the vertices dual to the bounding lines
common intersection
lowest point p*

16. The reduction – an attempt
By duality, obtain a set of points H*={h1*,h2*…hn*} dual to the bounding lines of the half-plane set H={h1…hn}
Obtain a path by connecting the points in H* with segments according to their order in H*
This does not work!!!
The obtained path may not be a simple path!

17. The reduction – a new approach
Partition the half-plane set H into two subsets
H1: half-planes whose bounding lines have negative slopes
H2: half-planes whose bounding lines have positive slopes
For each query q(i,j), the subset Hij is also partitioned into two subsets: Hij1 and Hij2 p*

18. Why do we partition H?
By duality, obtain a set of points H1*dual to the bounding lines of the half-plane set H1
Obtain a path by connecting the points in H1* according to their order in H1*
The obtained path is a simple path!
The data structure for the subpath convex hull queries of a simple path can be applied
In summary, a data structure for 2-D sublist LP queries:
Construction time: O(nlogn)
Query time: O(logn)
More efficient data structures are possible if the slopes of all bounding lines in H are given sorted

19. The discrete version
Each center fi must be at the position of a customer in P
O(nlog2n) time on a tree, Megiddo et al. 81’
O(nlogn) time, indicated by Tamir, 11’
Our results for the non-discrete versions are also applicable

20. Thank you