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

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

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’

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

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

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

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

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

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

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

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.

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*

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

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’

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*

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!

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*

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

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

Thank you