[Paper Review] The $p$-Center Problem in Tree Networks Revisited

Aritra Banik, Binay Bhattacharya+3 more|arXiv (Cornell University)|Apr 26, 2016

Facility Location and Emergency Management18 references3 citations

TL;DR

This paper presents two improved algorithms for the weighted discrete $p$-center problem on tree networks: one running in $O(n\log n + p\log^2 n\log(n/p))$ time and another in $O(n\log n + p^2\log^2(n/p))$ time. The key innovation lies in spine tree decomposition and a root-centric center placement policy, enabling faster feasibility testing via fractional cascading and AKS-like sorting networks, achieving the first improvement over the 30-year-old $O(n\log^2 n)$ bound for general $p$. The new algorithm outperforms prior work when $p = O(\sqrt{n})$ and offers a sub-quadratic solution for minmax regret $p$-center queries.

ABSTRACT

We present two improved algorithms for weighted discrete $p$-center problem for tree networks with $n$ vertices. One of our proposed algorithms runs in $O(n \log n + p \log^2 n \log(n/p))$ time. For all values of $p$, our algorithm thus runs as fast as or faster than the most efficient $O(n\log^2 n)$ time algorithm obtained by applying Cole's speed-up technique [cole1987] to the algorithm due to Megiddo and Tamir [megiddo1983], which has remained unchallenged for nearly 30 years. Our other algorithm, which is more practical, runs in $O(n \log n + p^2 \log^2(n/p))$ time, and when $p=O(\sqrt{n})$ it is faster than Megiddo and Tamir's $O(n \log^2n \log\log n)$ time algorithm [megiddo1983].

Motivation & Objective

• To address the long-standing open question of whether a $p$-center algorithm on tree networks can run faster than $O(n\log^2 n)$ for arbitrary $p$.
• To improve upon the $O(n\log^2 n\log\log n)$ time algorithm by Megiddo and Tamir (1983), which had remained unchallenged for nearly three decades.
• To develop practical and asymptotically efficient algorithms for the weighted discrete $p$-center problem on tree networks.
• To enable efficient dynamic updates for minmax regret $p$-center queries by supporting weight-increased vertex queries in $O(p\log(n/p)\log n)$ time.

Proposed method

• Employ spine tree decomposition to limit tree height to $O(\log n)$, simplifying hierarchical processing of centers.
• Introduce a root-centric location policy to guide optimal center placement based on subtree coverage and cost lines.
• Use fractional cascading to accelerate feasibility tests by reducing the number of comparisons across spine levels.
• Design an $O(p\log(n/p))$-time feasibility test for a given $\alpha$-value using upper envelope computation and cost line intersections.
• Apply AKS-like sorting networks with Cole’s speed-up to reduce the total number of feasibility tests to $O(\log^2 n)$, achieving near-optimal performance.
• Preprocess upper envelopes and bending point sequences in $O(n\log n)$ time to support fast dynamic queries under vertex weight changes.

Experimental results

Research questions

• RQ1 Can the $p$-center problem on tree networks be solved in time faster than $O(n\log^2 n)$ for arbitrary $p$?
• RQ2 Is it possible to design a practical algorithm that outperforms the $O(n\log^2 n\log\log n)$ algorithm of Megiddo and Tamir when $p = O(\sqrt{n})$?
• RQ3 Can fractional cascading and spine decomposition be leveraged to reduce the number of feasibility tests in parametric search for the $p$-center problem?
• RQ4 How can dynamic updates to vertex weights be supported efficiently without recomputing preprocessing data?
• RQ5 Can the proposed framework be extended to solve the minmax regret $p$-center problem in sub-quadratic time?

Key findings

• The proposed algorithm runs in $O(n\log n + p\log^2 n\log(n/p))$ time, improving upon the $O(n\log^2 n)$ bound from Cole’s speed-up of Megiddo and Tamir’s algorithm.
• For $p = O(\sqrt{n})$, the practical algorithm runs in $O(n\log n + p^2\log^2(n/p))$ time, which is faster than the $O(n\log^2 n\log\log n)$ algorithm of Megiddo and Tamir.
• The feasibility test for a given $\alpha$-value runs in $O(p\log(n/p))$ time after $O(n\log n)$ preprocessing, enabling efficient parametric search.
• Fractional cascading reduces the number of feasibility test calls by a factor of $O(\log n)$, contributing to the improved time complexity.
• The algorithm supports dynamic queries where a vertex weight is increased arbitrarily, answering such queries in $O(p\log(n/p)\log n)$ time without recomputing upper envelopes.
• The framework enables a sub-quadratic solution for the minmax regret $p$-center problem on trees, with $O(p\log(n/p)\log n)$ query time after $O(n\log n)$ preprocessing.