Covering Uncertain Points in a Tree

TL;DR

This paper introduces a novel algorithm to optimally cover uncertain demand points in a tree with facilities, minimizing the number of centers needed to ensure expected coverage within a specified range.

Contribution

It presents the first solution to a new coverage problem for uncertain points in trees, with an efficient algorithm and an application to the k-center problem.

Findings

Algorithm runs in O(|T|+M log^2 M) time.

Successfully solves the new coverage problem for uncertain points.

Extends to solve the k-center problem on trees for uncertain points.

Abstract

In this paper, we consider a coverage problem for uncertain points in a tree. Let T be a tree containing a set P of n (weighted) demand points, and the location of each demand point P_i\in P is uncertain but is known to appear in one of m_i points on T each associated with a probability. Given a covering range \lambda, the problem is to find a minimum number of points (called centers) on T to build facilities for serving (or covering) these demand points in the sense that for each uncertain point P_i\in P, the expected distance from P_i to at least one center is no more than $\lambda$. The problem has not been studied before. We present an O(|T|+M\log^2 M) time algorithm for the problem, where |T| is the number of vertices of T and M is the total number of locations of all uncertain points of P, i.e., M=\sum_{P_i\in P}m_i. In addition, by using this algorithm, we solve a k-center problem on T for the uncertain points of P.

Equations

$$\mathsf{E}\mathrm{d}(x,P_i)=w_i\cdot \sum _{j=1}^{m_i}{f}_{ij}\cdot d(x,p_{ij}).$$

$$\begin{array}{rl}& \mathsf{E}\mathrm{d}(x,P_i)=w_i\cdot \sum _{p_{ij}\in T}{f}_{ij}\cdot d(x,p_{ij})\\ & =w_i\cdot \sum _{p_{ij}\in T(y_1,\mu )}{f}_{ij}\cdot d(x,p_{ij})+w_i\cdot \sum _{p_{ij}\in T(y_2,\mu )}{f}_{ij}\cdot d(x,p_{ij})\\ & =w_i\cdot [F(i,y_1,\mu )\cdot (a_x+b_x)+D(i,y_1,\mu )]+w_i\cdot [F(i,y_2,\mu )\cdot (a_x+d(y_1,y_2)-b_x)+D(i,y_2,\mu )]\\ & =w_i\cdot [a_x+(F(i,y_1,\mu )-F(i,y_2,\mu ))\cdot b_x+D(i,y_1,\mu )+D(i,y_2,\mu )+F(i,y_2,\mu )\cdot d(y_1,y_2)].\end{array}$$

Full text

1 Introduction

Data uncertainty is very common in many applications, such as sensor databases, image resolution, facility location services, and it is mainly due to measurement inaccuracy, sampling discrepancy, outdated data sources, resource limitation, etc. Problems on uncertain data have attracted considerable attention, e.g., [1, 2, 3, 13, 14, 17, 25, 26, 35, 36, 37]. In this paper, we study a problem of covering uncertain points on a tree. The problem is formally defined as follows.

Let $T$ be a tree. We consider each edge $e$ of $T$ as a line segment of a positive length so that we can talk about “points” on $e$. Formally, we specify a point $x$ of $T$ by an edge $e$ of $T$ that contains $x$ and the distance between $x$ and an incident vertex of $e$. The distance of any two points $p$ and $q$ on $T$, denoted by $d(p,q)$, is defined as the sum of the lengths of all edges on the simple path from $p$ to $q$ in $T$. Let $\mathcal{P}=\{P_{1},\ldots,P_{n}\}$ be a set of $n$ uncertain (demand) points on $T$. Each $P_{i}\in\mathcal{P}$ has $m_{i}$ possible locations on $T$, denoted by $\{p_{i1},p_{i2},\cdots,p_{im_{i}}\}$, and each location $p_{ij}$ of $P_{i}$ is associated with a probability $f_{ij}\geq 0$ for $P_{i}$ appearing at $p_{ij}$ (which is independent of other locations), with $\sum_{j=1}^{m_{i}}f_{ij}=1$; e.g., see Fig. 1. In addition, each $P_{i}\in\mathcal{P}$ has a weight $w_{i}\geq 0$. For any point $x$ on $T$, the (weighted) expected distance from $x$ to $P_{i}$, denoted by $\mathsf{E}\mathrm{d}(x,P_{i})$, is defined as

[TABLE]

Given a value $\lambda\geq 0$, called the covering range, we say that a point $x$ on $T$ covers an uncertain point $P_{i}$ if $\mathsf{E}\mathrm{d}(x,P_{i})\leq\lambda$. The center-coverage problem is to compute a minimum number of points on $T$, called centers, such that every uncertain point of $\mathcal{P}$ is covered by at least one center (hence we can build facilities on these centers to “serve” all demand points).

To the best of our knowledge, the problem has not been studied before. Let $M$ denote the total number of locations all uncertain points, i.e., $M=\sum_{i=1}^{n}m_{i}$. Let $|T|$ be the number of vertices of $T$. In this paper, we present an algorithm that solves the problem in $O(|T|+M\log^{2}M)$ time, which is nearly linear as the input size of the problem is $\Theta(|T|+M)$.

As an application of our algorithm, we also solve a dual problem, called the $k$-center problem, which is to compute a number of $k$ centers on $T$ such that the covering range is minimized. Our algorithm solves the $k$-center problem in $O(|T|+n^{2}\log n\log M+M\log^{2}M\log n)$ time.

1.1 Related Work

Two models on uncertain data have been commonly considered: the existential model [3, 25, 26, 35, 36, 41] and the locational model [1, 2, 14, 37]. In the existential model an uncertain point has a specific location but its existence is uncertain while in the locational model an uncertain point always exists but its location is uncertain and follows a probability distribution function. Our problems belong to the locational model. In fact, the same problems under existential model are essentially the weighted case for “deterministic” points (i.e., each $P_{i}\in\mathcal{P}$ has a single “certain” location), and the center-coverage problem is solvable in linear time [28] and the $k$-center problem is solvable in $O(n\log^{2}n)$ time [15, 32].

If $T$ is a path, both the center-coverage problem and the $k$-center problem on uncertain points have been studied [39], but under a somewhat special problem setting where $m_{i}$ is the same for all $1\leq i\leq n$. The two problems were solved in $O(M+n\log k)$ and $O(M\log M+n\log k\log n)$ time, respectively. If $T$ is tree, an $O(|T|+M)$ time algorithm was given in [40] for the one-center problem under the above special problem setting.

As mentioned above, the “deterministic” version of the center-coverage problem is solvable in linear time [28], where all demand points are on the vertices. For the $k$-center problem, Megiddo and Tamir [32] presented an $O(n\log^{2}n\log\log n)$ time algorithm ($n$ is the size of the tree), which was improved to $O(n\log^{2}n)$ time by Cole [15]. The unweighted case was solved in linear time by Frederickson [18].

Very recently, Li and Huang [23] considered the same $k$-center problem under the same uncertain model as ours but in the Euclidean space, and they gave an approximation algorithm. Facility location problems in other uncertain models have also been considered. For example, Löffler and van Kreveld [30] gave algorithms for computing the smallest enclosing circle for imprecise points each of which is contained in a planar region (e.g., a circle or a square). Jørgenson et al. [24] studied the problem of computing the distribution of the radius of the smallest enclosing circle for uncertain points each of which has multiple locations in the plane. de Berg et al. [16] proposed algorithms for dynamically maintaining Euclidean $2$-centers for a set of moving points in the plane (the moving points are considered uncertain). See also the problems for minimizing the maximum regret, e.g., [5, 6, 38].

Some coverage problems in various geometric settings have also been studied. For example, the unit disk coverage problem is to compute a minimum number of unit disks to cover a given set of points in the plane. The problem is NP-hard and a polynomial-time approximation scheme was known [22]. The discrete case where the disks must be selected from a given set was also studied [34]. See [9, 11, 20, 29] and the references therein for various problems of covering points using squares. Refer to a survey [4] for more geometric coverage problems.

1.2 Our Techniques

We first discuss our techniques for solving the center-coverage problem.

For each uncertain point $P_{i}\in\mathcal{P}$, we find a point $p^{*}_{i}$ on $T$ that minimizes the expected distance $\mathsf{E}\mathrm{d}(p_{i},P_{i})$, and $p^{*}_{i}$ is actually the weighted median of all locations of $P_{i}$. We observe that if we move a point $x$ on $T$ away from $p_{i}^{*}$, the expected distance $\mathsf{E}\mathrm{d}(x,P_{i})$ is monotonically increasing. We compute the medians $p_{i}^{*}$ for all uncertain points in $O(M\log M)$ time. Then we show that there exists an optimal solution in which all centers are in $T_{m}$, where $T_{m}$ is the minimum subtree of $T$ that connects all medians $p_{i}^{*}$ (so every leaf of $T_{m}$ is a median $p_{i}^{*}$). Next we find centers on $T_{m}$. To this end, we propose a simple greedy algorithm, but the challenge is on developing efficient data structures to perform certain operations. We briefly discuss it below.

We pick an arbitrary vertex $r$ of $T_{m}$ as the root. Starting from the leaves, we consider the vertices of $T_{m}$ in a bottom-up manner and place centers whenever we “have to”. For example, consider a leaf $v$ holding a median $p_{i}^{*}$ and let $u$ be the parent of $v$. If $\mathsf{E}\mathrm{d}(u,P_{i})>\lambda$, then we have to place a center $c$ on the edge $e(u,v)$ in order to cover $P_{i}$. The location of $c$ is chosen to be at a point of $e(u,v)$ with $\mathsf{E}\mathrm{d}(c,P_{i})=\lambda$ (i.e., on the one hand, $c$ covers $P_{i}$, and on the other hand, $c$ is as close to $u$ as possible in the hope of covering other uncertain points as many as possible). After $c$ is placed, we find and remove all uncertain points that are covered by $c$. Performing this operation efficiently is a key difficulty for our approach. We solve the problem in an output-sensitive manner by proposing a dynamic data structure that also supports the remove operations.

We also develop data structures for other operations needed in the algorithm. For example, we build a data structure in $O(M\log M)$ time that can compute the expected distance $\mathsf{E}\mathrm{d}(x,P_{i})$ in $O(\log M)$ time for any point $x$ on $T$ and any $P_{i}\in\mathcal{P}$. These data structures may be of independent interest.

We should point out that our algorithm is essentially different from the one in our previous work [40]. Indeed, our algorithm here is a greedy algorithm while the one in [40] uses the prune-and-search technique. Also our algorithm relies heavily on some data structures as mentioned above while the algorithm in [40] does not need any of these data structures.

For solving the $k$-center problem, by observations, we first identify a set of $O(n^{2})$ “candidate” values such that the covering range in the optimal solution must be in the set. Subsequently, we use our algorithm for the center-coverage problem as a decision procedure to find the optimal covering range in the set.

Note that although we have assumed $\sum_{j=1}^{m_{i}}f_{ij}=1$ for each $P_{i}\in\mathcal{P}$, it is quite straightforward to adapt our algorithm to the general case where the assumption does not hold.

The rest of the paper is organized as follows. We introduce some notation in Section 2. In Section 3, we describe our algorithmic scheme for the center-coverage problem but leave the implementation details in the subsequent two sections. Specifically, the algorithm for computing all medians $p_{i}^{*}$ is given in Section 4, and in the same section we also propose a connector-bounded centroid decomposition of $T$, which is repeatedly used in the paper and may be interesting in its own right. The data structures used in our algorithmic scheme are given in Section 5. We finally solve the $k$-center problem in Section 6.

2 Preliminaries

Note that the locations of the uncertain points of $\mathcal{P}$ may be in the interior of the edges of $T$. A vertex-constrained case happens if all locations of $\mathcal{P}$ are at vertices of $T$ and each vertex of $T$ holds at least one location of $\mathcal{P}$ (but the centers we seek can still be in the interior of edges). As in [40], we will show later in Section 5.4 that the general problem can be reduced to the vertex-constrained case in $O(|T|+M)$ time. In the following, unless otherwise stated, we focus our discussion on the vertex-constrained case and assume our problem on $\mathcal{P}$ and $T$ is a vertex-constrained case. For ease of exposition, we further make a general position assumption that every vertex of $T$ has only one location of $\mathcal{P}$ (we explain in Section 5.4 that our algorithm easily extends to the degenerate case). Under this assumption, it holds that $|T|=M\geq n$.

Let $e(u,v)$ denote the edge of $T$ incident to two vertices $u$ and $v$. For any two points $p$ and $q$ on $T$, denote by $\pi(p,q)$ the simple path from $p$ to $q$ on $T$.

Let $\pi$ be any simple path on $T$ and $x$ be any point on $\pi$. For any location $p_{ij}$ of an uncertain point $P_{i}$, the distance $d(x,p_{ij})$ is a convex (and piecewise linear) function as $x$ changes on $\pi$ [31]. As a sum of multiple convex functions, $\mathsf{E}\mathrm{d}(x,P_{i})$ is also convex (and piecewise linear) on $\pi$, that is, in general, as $x$ moves on $\pi$, $\mathsf{E}\mathrm{d}(x,P_{i})$ first monotonically decreases and then monotonically increases. In particular, for each edge $e$ of $T$, $\mathsf{E}\mathrm{d}(x,P_{i})$ is a linear function for $x\in e$.

For any subtree $T^{\prime}$ of $T$ and any $P_{i}\in\mathcal{P}$, we call the sum of the probabilities of the locations of $P_{i}$ in $T^{\prime}$ the probability sum of $P_{i}$ in $T^{\prime}$.

For each uncertain point $P_{i}$, let $p_{i}^{*}$ be a point $x\in T$ that minimizes $\mathsf{E}\mathrm{d}(x,P_{i})$. If we consider $w_{i}\cdot f_{ij}$ as the weight of $p_{ij}$, $p_{i}^{*}$ is actually the weighted median of all points $p_{ij}\in P_{i}$. We call $p_{i}^{*}$ the median of $P_{i}$. Although $p_{i}^{*}$ may not be unique (e.g., when there is an edge $e$ dividing $T$ into two subtrees such that the probability sum of $P_{i}$ in either subtree is exactly $0.5$), $P_{i}$ always has a median located at a vertex $v$ of $T$, and we let $p_{i}^{*}$ refer to such a vertex.

Recall that $\lambda$ is the given covering range for the center-coverage problem. If $\mathsf{E}\mathrm{d}(p_{i}^{*},P_{i})>\lambda$ for some $i\in[1,n]$, then there is no solution for the problem since no point of $T$ can cover $P_{i}$. Henceforth, we assume $\mathsf{E}\mathrm{d}(p_{i}^{*},P_{i})\leq\lambda$ for each $i\in[1,n]$.

3 The Algorithmic Scheme

In this section, we describe our algorithmic scheme for the center-coverage problem, and the implementation details will be presented in the subsequent two sections.

We start with computing the medians $p_{i}^{*}$ of all uncertain points of $\mathcal{P}$. We have the following lemma, whose proof is deferred to Section 4.2.

Lemma 1

The medians $p_{i}^{*}$ of all uncertain points $P_{i}$ of $\mathcal{P}$ can be computed in $O(M\log M)$ time.

3.1 The Medians-Spanning Tree $T_{m}$

Denote by $P^{*}$ the set of all medians $p_{i}^{*}$. Let $T_{m}$ be the minimum connected subtree of $T$ that spans/connects all medians. Note that each leaf of $T_{m}$ must hold a median. We pick an arbitrary median as the root of $T$, denoted by $r$. The subtree $T_{m}$ can be easily computed in $O(M)$ time by a post-order traversal on $T$ (with respect to the root $r$), and we omit the details. The following lemma is based on the fact that $\mathsf{E}\mathrm{d}(x,P_{i})$ is convex for $x$ on any simple path of $T$ and $\mathsf{E}\mathrm{d}(x,P_{i})$ minimizes at $x=p_{i}^{*}$.

Lemma 2

There exists an optimal solution for the center-coverage problem in which every center is on $T_{m}$.

Proof

Consider an optimal solution and let $C$ be the set of all centers in it. Assume there is a center $c\in C$ that is not on $T_{m}$. Let $v$ be the vertex of $T_{m}$ that holds a median and is closest to $c$. Then $v$ decomposes $T$ into two subtrees $T_{1}$ and $T_{2}$ with the only common vertex $v$ such that $c$ is in one subtree, say $T_{1}$, and all medians are in $T_{2}$. If we move a point $x$ from $c$ to $v$ along $\pi(c,v)$, then $\mathsf{E}\mathrm{d}(x,P_{i})$ is non-increasing for each $i\in[1,n]$. This implies that if we move the center $c$ to $v$, we can obtain an optimal solution in which $c$ is in $T_{m}$.

If $C$ has other centers that are not on $T_{m}$, we do the same as above to obtain an optimal solution in which all centers are on $T_{m}$. The lemma thus follows. ∎

Due to Lemma 2, we will focus on finding centers on $T_{m}$. We also consider $r$ as the root of $T_{m}$. With respect to $r$, we can talk about ancestors and descendants of the vertices in $T_{m}$. Note that for any two vertices $u$ and $v$ of $T_{m}$, $\pi(u,v)$ is in $T_{m}$.

We reindex all medians and the corresponding uncertain points so that the new indices will facilitate our algorithm, as follows. Starting from an arbitrary child of $r$ in $T_{m}$, we traverse down the tree $T_{m}$ by always following the leftmost child of the current node until we encounter a leaf, denoted by $v^{*}$. Starting from $v^{*}$ (i.e., $v^{*}$ is the first visited leaf), we perform a post-order traversal on $T_{m}$ and reindex all medians of $P^{*}$ such that $p_{1}^{*},p_{2}^{*},\ldots,p^{*}_{n}$ is the list of points of $P^{*}$ visited in order in the above traversal. Recall that the root $r$ contains a median, which is $p^{*}_{n}$ after the reindexing. Accordingly, we also reindex all uncertain points of $\mathcal{P}$ and their corresponding locations on $T$, which can be done in $O(M)$ time. In the following paper, we will always use the new indices.

For each vertex $v$ of $T_{m}$, we use $T_{m}(v)$ to represent the subtree of $T_{m}$ rooted at $v$. The reason we do the above reindexing is that for any vertex $v$ of $T_{m}$, the new indices of all medians in $T_{m}(v)$ must form a range $[i,j]$ for some $1\leq i\leq j\leq n$, and we use $R(v)$ to denote the range. It will be clear later that this property will facilitate our algorithm.

3.2 The Algorithm

Our algorithm for the center-coverage problem works as follows. Initially, all uncertain points are “active”. During the algorithm, we will place centers on $T_{m}$, and once an uncertain point $P_{i}$ is covered by a center, we will “deactivate” it (it then becomes “inactive”). The algorithm visits all vertices of $T_{m}$ following the above post-order traversal of $T_{m}$ starting from leaf $v^{*}$. Suppose $v$ is currently being visited. Unless $v$ is the root $r$, let $u$ be the parent of $v$. Below we describe our algorithm for processing $v$. There are two cases depending on whether $v$ is a leaf or an internal node, although the algorithm for them is essentially the same.

3.2.1 The Leaf Case

If $v$ is a leaf, then it holds a median $p_{i}^{*}$. If $P_{i}$ is inactive, we do nothing; otherwise, we proceed as follows.

We compute a point $c$ (called a candidate center) on the path $\pi(v,r)$ closest to $r$ such that $\mathsf{E}\mathrm{d}(c,P_{i})\leq\lambda$. Note that if we move a point $x$ from $v$ to $r$ along $\pi(v,r)$, $\mathsf{E}\mathrm{d}(x,P_{i})$ is monotonically increasing. By the definition of $c$, if $\mathsf{E}\mathrm{d}(r,P_{i})\leq\lambda$, then $c=r$; otherwise, $\mathsf{E}\mathrm{d}(c,P_{i})=\lambda$. If $c$ is in $\pi(u,r)$, then we do nothing and finish processing $v$. Below we assume that $c$ is not in $\pi(u,r)$ and thus is in $e(u,v)\setminus\{u\}$ (i.e., $c\in e(u,v)$ but $c\neq u$).

In order to cover $P_{i}$, by the definition of $c$, we must place a center in $e(u,v)\setminus\{u\}$. Our strategy is to place a center at $c$. Indeed, this is the best location for placing a center since it is the location that can cover $P_{i}$ and is closest to $u$ (and thus is closest to every other active uncertain point). We use a candidate-center-query to compute $c$ in $O(\log n)$ time, whose details will be discussed later. Next, we report all active uncertain points that can be covered by $c$, and this is done by a coverage-report-query in output-sensitive $O(\log M\log n+k\log n)$ amortized time, where $k$ is the number of uncertain points covered by $c$. The details for the operation will be discussed later. Further, we deactivate all these uncertain points. We will show that deactivating each uncertain point $P_{j}$ can be done in $O(m_{j}\log M\log n)$ amortized time. This finishes processing $v$.

3.2.2 The Internal Node Case

If $v$ is an internal node, since we process the vertices of $T_{m}$ following a post-order traversal, all descendants of $v$ have already been processed. Our algorithm maintains an invariant that if the subtree $T_{m}(v)$ contains any active median $p_{i}^{*}$ (i.e., $P_{i}$ is active), then $\mathsf{E}\mathrm{d}(v,P_{i})\leq\lambda$. When $v$ is a leaf, this invariant trivially holds. Our way of processing a leaf discussed above also maintains this invariant.

To process $v$, we first check whether $T_{m}(v)$ has any active medians. This is done by a range-status-query in $O(\log n)$ time, whose details will be given later. If $T_{m}(v)$ does not have any active median, then we are done with processing $v$. Otherwise, by the algorithm invariant, for each active median $p_{i}^{*}$ in $T_{m}(v)$, it holds that $\mathsf{E}\mathrm{d}(v,P_{i})\leq\lambda$. If $v=r$, we place a center at $v$ and finish the entire algorithm. Below, we assume $v$ is not $r$ and thus $u$ is the parent of $v$.

We compute a point $c$ on $\pi(v,r)$ closest to $r$ such that $\mathsf{E}\mathrm{d}(c,P_{i})\leq\lambda$ for all active medians $p_{i}^{*}\in T_{m}(v)$, and we call $c$ the candidate center. By the definition of $c$, if $\mathsf{E}\mathrm{d}(r,P_{i})\leq\lambda$ for all active medians $p_{i}^{*}\in T_{m}(v)$, then $c=r$; otherwise, $\mathsf{E}\mathrm{d}(c,P_{i})=\lambda$ for some active median $p_{i}^{*}\in T_{m}(v)$. As in the leaf case, finding $c$ is done in $O(\log n)$ time by a candidate-center-query. If $c$ is on $\pi(u,r)$, then we finish processing $v$. Note that this implies $\mathsf{E}\mathrm{d}(u,P_{i})\leq\lambda$ for each active median $p_{i}^{*}\in T_{m}(v)$, which maintains the algorithm invariant for $u$.

If $c\not\in\pi(u,r)$, then $c\in e(u,v)\setminus\{u\}$. In this case, by the definition of $c$, we must place a center in $e(u,v)\setminus\{u\}$ to cover $P_{i}$. As discussed in the leaf case, the best location for placing a center is $c$ and thus we place a center at $c$. Then, by using a coverage-report-query, we find all active uncertain points covered by $c$ and deactivate them. Note that by the definition of $c$, $c$ covers $P_{j}$ for all medians $p_{j}^{*}\in T_{m}(v)$. This finishes processing $v$.

Once the root $r$ is processed, the algorithm finishes.

3.3 The Time Complexity

To analyze the running time of the algorithm, it remains to discuss the three operations: range-status-queries, coverage-report-queries, and candidate-center-queries. For answering range-status-queries, it is trivial, as shown in Lemma 3.

Lemma 3

We can build a data structure in $O(M)$ time that can answer each range-status-query in $O(\log n)$ time. Further, once an uncertain point is deactivated, we can remove it from the data structure in $O(\log n)$ time.

Proof

Initially we build a balanced binary search tree $\Phi$ to maintain all indices $1,2,\ldots,n$. If an uncertain point $P_{i}$ is deactivated, then we simply remove $i$ from the tree in $O(\log n)$ time.

For each range-status-query, we are given a vertex $v$ of $T_{m}$, and the goal is to decide whether $T_{m}(v)$ has any active medians. Recall that all medians in $T_{m}(v)$ form a range $R(v)=[i,j]$. As preprocessing, we compute $R(v)$ for all vertices $v$ of $T_{m}$, which can be done in $O(|T_{m}|)$ time by the post-order traversal of $T_{m}$ starting from leaf $v^{*}$. Note that $|T_{m}|=O(M)$.

During the query, we simply check whether $\Phi$ still contains any index in the range $R(v)=[i,j]$, which can be done in $O(\log n)$ time by standard approaches (e.g., by finding the successor of $i$ in $\Phi$). ∎

For answering the coverage-report-queries and the candidate-center-queries, we have the following two lemmas. Their proofs are deferred to Section 5.

Lemma 4

We can build a data structure $\mathcal{A}_{1}$ in $O(M\log^{2}M)$ time that can answer in $O(\log M\log n+k\log n)$ amortized time each coverage-report-query, i.e., given any point $x\in T$, report all active uncertain points covered by $x$, where $k$ is the output size. Further, if an uncertain point $P_{i}$ is deactivated, we can remove $P_{i}$ from $\mathcal{A}_{1}$ in $O(m_{i}\cdot\log M\cdot\log n)$ amortized time.

Lemma 5

We can build a data structure $\mathcal{A}_{2}$ in $O(M\log M+n\log^{2}M)$ time that can answer in $O(\log n)$ time each candidate-center-query, i.e., given any vertex $v\in T_{m}$, find the candidate center $c$ for the active medians of $T_{m}(v)$. Further, if an uncertain point $P_{i}$ is deactivated, we can remove $P_{i}$ from $\mathcal{A}_{2}$ in $O(\log n)$ time.

Using these results, we obtain the following.

Theorem 3.1

We can find a minimum number of centers on $T$ to cover all uncertain points of $\mathcal{P}$ in $O(M\log^{2}M)$ time.

Proof

First of all, the total preprocessing time of Lemmas 3, 4, and 5 is $O(M\log^{2}M)$. Computing all medians takes $O(M\log M)$ time by Lemma 1. Below we analyze the total time for computing centers on $T_{m}$.

The algorithm processes each vertex of $T_{m}$ exactly once. The processing of each vertex calls each of the following three operations at most once: coverage-report-queries, range-status-queries, and candidate-center-queries. Since each of the last two operations runs in $O(\log n)$ time, the total time of these two operations in the entire algorithm is $O(M\log n)$. For the coverage-report-queries, each operation runs in $O(\log M\log n+k\log n)$ amortized time. Once an uncertain point $P_{i}$ is reported by it, $P_{i}$ will be deactivated by removing it from all three data structures (i.e., those in Lemmas 3, 4, and 5) and $P_{i}$ will not become active again. Therefore, each uncertain point will be reported by the coverage-report-query operations at most once. Hence, the total sum of the value $k$ in the entire algorithm is $n$. Further, notice that there are at most $n$ centers placed by the algorithm. Hence, there are at most $n$ coverage-report-query operations in the algorithm. Therefore, the total time of the coverage-report-queries in the entire algorithm is $O(n\log M\log n)$. In addition, since each uncertain point $P_{i}$ will be deactivated at most once, the total time of the remove operations for all three data structures in the entire algorithm is $O(M\log M\log n)$ time.

As $n\leq M$, the theorem follows. ∎

In addition, Lemma 6 will be used to build the data structure $\mathcal{A}_{2}$ in Lemma 5, and it will also help to solve the $k$-center problem in Section 6. Its proof is given in Section 5.

Lemma 6

We can build a data structure $\mathcal{A}_{3}$ in $O(M\log M)$ time that can compute the expected distance $\mathsf{E}\mathrm{d}(x,P_{i})$ in $O(\log M)$ time for any point $x\in T$ and any uncertain point $P_{i}\in\mathcal{P}$.

4 A Tree Decomposition and Computing the Medians

In this section, we first introduce a decomposition of $T$, which will be repeatedly used in our algorithms (e.g., for Lemmas 1, 4, 6). Later in Section 4.2 we will compute the medians with the help of the decomposition.

4.1 A Connector-Bounded Centroid Decomposition

We propose a tree decomposition of $T$, called a connector-bounded centroid decomposition, which is different from the centroid decompositions used before, e.g., [19, 28, 32, 33] and has certain properties that can facilitate our algorithms.

A vertex $v$ of $T$ is called a centroid if $T$ can be represented as a union of two subtrees with $v$ as their only common vertex and each subtree has at most $\frac{2}{3}$ of the vertices of $T$ [28, 33], and we say the two subtrees are decomposed by $v$. Such a centroid always exists and can be found in linear time [28, 33]. For convenience of discussion, we consider $v$ to be contained in only one subtree but an “open vertex” in the other subtree (thus, the location of $\mathcal{P}$ at $v$ only belongs to one subtree).

Our decomposition of $T$ corresponds to a decomposition tree, denoted by $\Upsilon$ and defined recursively as follows. Each internal node of $\Upsilon$ has two, three, or four children. The root of $\Upsilon$ corresponds to the entire tree $T$. Let $v$ be a centroid of $T$, and let $T_{1}$ and $T_{2}$ be the subtrees of $T$ decomposed by $v$. Note that $T_{1}$ and $T_{2}$ are disjoint since we consider $v$ to be contained in only one of them. Further, we call $v$ a connector in both $T_{1}$ and $T_{2}$. Correspondingly, in $\Upsilon$, its root has two children corresponding to $T_{1}$ and $T_{2}$, respectively.

In general, consider a node $\mu$ of $\Upsilon$. Let $T(\mu)$ represent the subtree of $T$ corresponding to $\mu$. We assume $T(\mu)$ has at most two connectors (initially this is true when $\mu$ is the root). We further decompose $T(\mu)$ into subtrees that correspond to the children of $\mu$ in $\Upsilon$, as follows. Let $v$ be the centroid of $T(\mu)$ and let $T_{1}(\mu)$ and $T_{2}(\mu)$ respectively be the two subtrees of $T(\mu)$ decomposed by $v$. We consider $v$ as a connector in both $T_{1}(\mu)$ and $T_{2}(\mu)$.

If $T(\mu)$ has at most one connector, then each of $T_{1}(\mu)$ and $T_{2}(\mu)$ has at most two connectors. In this case, $\mu$ has two children corresponding to $T_{1}(\mu)$ and $T_{2}(\mu)$, respectively.

If $T(\mu)$ has two connectors but each of $T_{1}(\mu)$ and $T_{2}(\mu)$ still has at most two connectors (with $v$ as a new connector), then $\mu$ has two children corresponding to $T_{1}(\mu)$ and $T_{2}(\mu)$, respectively. Otherwise, one of them, say, $T_{2}(\mu)$, has three connectors and the other $T_{1}(\mu)$ has only one connector (e.g., see Fig. 2). In this case, $\mu$ has a child in $\Upsilon$ corresponding to $T_{1}(\mu)$, and we further perform a connector-reducing decomposition on $T_{2}(\mu)$, as follows (this is the main difference between our decomposition and the traditional centroid decomposition used before [19, 28, 32, 33]). Depending on whether the three connectors of $T_{2}(\mu)$ are in a simple path, there are two cases.

If they are in a simple path, without loss of generality, we assume $v$ is the one between the other two connectors in the path. We decompose $T_{2}(\mu)$ into two subtrees at $v$ such that they contain the two connectors respectively. In this way, each subtree contains at most two connectors. Correspondingly, $\mu$ has another two children corresponding the two subtrees of $T_{2}(\mu)$, and thus $\mu$ has three children in total. 2. 2.

Otherwise, there is a unique vertex $v^{\prime}$ in $T_{2}(\mu)$ that decomposes $T_{2}(\mu)$ into three subtrees that contain the three connectors respectively (e.g., see Fig. 2). Note that $v^{\prime}$ and the three subtrees can be easily found in linear time by traversing $T_{2}(\mu)$. Correspondingly, $\mu$ has another three children corresponding to the above three subtrees of $T_{2}(\mu)$, respectively, and thus $\mu$ has four children in total. Note that we consider $v^{\prime}$ as a connector in each of the above three subtrees. Thus, each subtree contains at most two connectors.

We continue the decomposition until each subtree $T(\mu)$ of $\mu\in\Upsilon$ becomes an edge $e(v_{1},v_{2})$ of $T$. According to our decomposition, both $v_{1}$ and $v_{2}$ are connectors of $T(\mu)$, but they may only open vertices of $T(\mu)$. If both $v_{1}$ and $v_{2}$ are open vertices of $T(\mu)$, then we will not further decompose $T(\mu)$, so $\mu$ is a leaf of $\Upsilon$. Otherwise, we further decompose $T(\mu)$ into an open edge and a closed vertex $v_{i}$ if $v_{i}$ is contained in $T(\mu)$ for each $i=1,2$. Correspondingly, $\mu$ has either two or three children that are leaves of $\Upsilon$. In this way, for each leaf $\mu$ of $\Upsilon$, $T(\mu)$ is either an open edge or a closed vertex of $T$. In the former case, $T(\mu)$ has two connectors that are its incident vertices, and in the latter case, $T(\mu)$ has one connector that is itself.

This finishes the decomposition of $T$. A major difference between our decomposition and the traditional centroid decomposition [19, 28, 32, 33] is that the subtree in our decomposition has at most two connectors. As will be clear later, this property is crucial to guarantee the runtime of our algorithms.

Lemma 7

The height of $\Upsilon$ is $O(\log M)$ and $\Upsilon$ has $O(M)$ nodes. The connector-bounded centroid decomposition of $T$ can be computed in $O(M\log M)$ time.

Proof

Consider any node $\mu$ of $\Upsilon$. Let $T(\mu)$ be the subtree of $T$ corresponding to $\mu$. According to our decomposition, $|T(\mu)|=O(M\cdot(\frac{2}{3})^{t})$, where $t$ is the depth of $\mu$ in $\Upsilon$. This implies that the height of $\Upsilon$ is $O(\log M)$.

Since each leaf of $\Upsilon$ corresponds to either a vertex or an open edge of $T$, the number of leaves of $\Upsilon$ is $O(M)$. Since each internal node of $\Upsilon$ has at least two children, the number of internal nodes is no more than the number of leaves. Hence, $\Upsilon$ has $O(M)$ nodes.

According to our decomposition, all subtrees of $T$ corresponding to all nodes in the same level of $\Upsilon$ (i.e., all nodes with the same depth) are pairwise disjoint, and thus the total size of all these subtrees is $O(M)$. Decomposing each subtree can be done in linear time (e.g., finding a centroid takes linear time). Therefore, decomposing all subtrees in each level of $\Upsilon$ takes $O(M)$ time. As the height of $\Upsilon$ is $O(\log M)$, the total time for computing the decomposition of $T$ is $O(M\log M)$. ∎

In the following, we assume our decomposition of $T$ and the decomposition tree $\Upsilon$ have been computed. In addition, we introduce some notation that will be used later. For each node $\mu$ of $\Upsilon$, we use $T(\mu)$ to represent the subtree of $T$ corresponding to $\mu$. If $y$ is a connector of $T(\mu)$, then we use $T(y,\mu)$ to represent the subtree of $T$ consisting of all points $q$ of $T\setminus T(\mu)$ such that $\pi(q,p)$ contains $y$ for any point $p\in T(\mu)$ (i.e., $T(y,\mu)$ is the “outside world” connecting to $T(\mu)$ through $y$; e.g., see Fig. 3). By this definition, if $y$ is the only connector of $T(\mu)$, then $T=T(\mu)\cup T(y,\mu)$; if $T(\mu)$ has two connectors $y_{1}$ and $y_{2}$, then $T=T(\mu)\cup T(y_{1},\mu)\cup T(y_{2},\mu)$.

4.2 Computing the Medians

In this section, we compute all medians. It is easy to compute the median $p_{i}^{*}$ for a single uncertain point $P_{i}$ in $O(M)$ time by traversing the tree $T$. Hence, a straightforward algorithm can compute all $n$ medians in $O(nM)$ time. Instead, we present an $O(M\log M)$ time algorithm, which will prove Lemma 1.

For any vertex $v$ (e.g., the centroid) of $T$, let $T_{1}$ and $T_{2}$ be two subtrees of $T$ decomposed by $v$ (i.e., $v$ is their only common vertex and $T=T_{1}\cup T_{2}$), such that $v$ is contained in only one subtree and is an open vertex in the other. The following lemma can be readily obtained from Kariv and Hakimi [27], and similar results were also given in [40].

Lemma 8

For any uncertain point $P_{i}$ of $\mathcal{P}$, we have the following.

If the probability sum of $P_{i}$ in $T_{j}$ is greater than $0.5$ for some $j\in\{1,2\}$, then the median $p_{i}^{*}$ must be in $T_{j}$. 2. 2.

The vertex $v$ is $p_{i}^{*}$ if the probability sum of $P_{i}$ in $T_{j}$ is equal to $0.5$ for some $j\in\{1,2\}$.

Consider the connector-bounded centroid decomposition $\Upsilon$ of $T$. Starting from the root of $\Upsilon$, our algorithm will process the nodes of $\Upsilon$ in a top-down manner. Suppose we are processing a node $\mu$. Then, we maintain a sorted list of indices for $\mu$, called the index list of $\mu$ and denoted by $L(\mu)$, which consists of all indices $i\in[1,n]$ such that $p_{i}^{*}$ is not found yet but is known to be in the subtree $T(\mu)$. Since each index $i$ of $L(\mu)$ essentially refers to $P_{i}$, for convenience, we also say that $L(\mu)$ is a set of uncertain points. Let $F[1\cdots n]$ be an array, which will help to compute the probability sums in our algorithm.

4.2.1 The Root Case

Initially, $\mu$ is the root and we process it as follows. We present our algorithm in a way that is consistent with that for the general case.

Since $\mu$ is the root, we have $T(\mu)=T$ and $L(\mu)=\{1,2,\ldots,n\}$. Let $\mu_{1}$ and $\mu_{2}$ be the two children of $\mu$. Let $v$ be the centroid of $T$ that is used to decompose $T(\mu)$ into $T(\mu_{1})$ and $T(\mu_{2})$ (e.g., see Fig. 3). We compute in $O(|T(\mu)|)$ time the probability sums of all uncertain points of $L(\mu)$ in $T(\mu_{1})$ by using the array $F$ and traversing $T(\mu_{1})$. Specifically, we first perform a reset procedure on $F$ to reset $F[i]$ to [math] for each $i\in L(\mu)$, by scanning the list $L(\mu)$. Then, we traverse $T(\mu_{1})$, and for each visited vertex, which holds some uncertain point location $p_{ij}$, we update $F[i]=F[i]+f_{ij}$. After the traversal, for each $i\in L(\mu)$, $F[i]$ is equal to the probability sum of $P_{i}$ in $T(\mu_{1})$. By Lemma 8, if $F[i]=0.5$, then $p_{i}^{*}$ is $v$ and we report $p_{i}^{*}=v$; if $F[i]>0.5$, then $p_{i}^{*}$ is in $T_{1}(\mu)$ and we add $i$ to the end of the index list $L(\mu_{1})$ for $\mu_{1}$ (initially $L(\mu_{1})=\emptyset$); if $F[i]<0.5$, then $p_{i}^{*}$ is in $T_{2}(\mu)$ and add $i$ to the end of $L(\mu_{2})$ for $\mu_{2}$. The above has correctly computed the index lists for $\mu_{1}$ and $\mu_{2}$.

Recall that $v$ is a connector in both $T(\mu_{1})$ and $T(\mu_{2})$. In order to efficiently compute medians in $T(\mu_{1})$ and $T(\mu_{2})$ recursively, we compute a probability list $L(v,\mu_{j})$ at $v$ for $\mu_{j}$ for each $j=1,2$. We discuss $L(v,\mu_{1})$ first.

The list $L(v,\mu_{1})$ is the same as $L(\mu_{1})$ except that each index $i\in L(v,\mu_{1})$ is also associated with a value, denoted by $F(i,v,\mu_{1})$, which is the probability sum of $P_{i}$ in $T(v,\mu_{1})$ (recall the definition of $T(v,\mu_{1})$ at the end of Section 4.1; note that $T(v,\mu_{1})=T(\mu_{2})$ in this case). The list $L(v,\mu_{1})$ can be built in $O(|T(\mu)|)$ time by traversing $T(\mu_{2})$ and using the array $F$. Specifically, we scan the list $L(\mu_{1})$, and for each index $i\in L(\mu_{1})$, we reset $F[i]=0$. Then, we traverse the subtree $T(\mu_{2})$, and for each location $p_{ij}$ in $T(\mu_{2})$, we update $F[i]=F[i]+f_{ij}$ (if $i$ is not in $L(\mu_{1})$, this step is actually redundant but does not affect anything). After the traversal, for each index $i\in L(\mu_{1})$, we copy it to $L(v,\mu_{1})$ and set $F(i,v,\mu_{1})=F[i]$.

Similarly, we compute the probability list $L(v,\mu_{2})$ at $v$ for $\mu_{2}$ in $O(|T(\mu)|)$ time by traversing $T(\mu_{1})$. This finishes the processing of the root $\mu$. The total time is $O(|T(\mu)|)$ since $|L(\mu)|\leq|T(\mu)|$. Note that our algorithm guarantees that for each $i\in L(\mu_{1})$, $P_{i}$ must have at least one location in $T(\mu_{1})$, and thus $|L(\mu_{1})|\leq|T(\mu_{1})|$. Similarly, for each $i\in L(\mu_{2})$, $P_{i}$ must have at least one location in $T(\mu_{2})$, and thus $|L(\mu_{2})|\leq|T(\mu_{2})|$.

4.2.2 The General Case

Let $\mu$ be an internal node of $\Upsilon$ such that the ancestors of $\mu$ have all been processed. Hence, we have a sorted index list $L(\mu)$. If $L(\mu)=\emptyset$, then we do not need to process $\mu$ and any of its descendants. We assume $L(\mu)\neq\emptyset$. Thus, for each $i\in L(\mu)$, $p_{i}^{*}$ is in $T(\mu)$ and $P_{i}$ has at least one location in $T(\mu)$ (and thus $|L(\mu)|\leq|T(\mu)|$). Further, for each connector $y$ of $T(\mu)$, the algorithm maintains a probability list $L(y,\mu)$ that is the same as $L(\mu)$ except that each index $i\in L(y,\mu)$ is associated with a value $F(i,y,\mu)$, which is the probability sum of $P_{i}$ in the subtree $T(y,\mu)$. Our processing algorithm for $\mu$ works as follows, whose total time is $O(|T(\mu)|)$.

According to our decomposition, $T(\mu)$ has at most two connectors and $\mu$ may have two, three, or four children. We first discuss the case where $\mu$ has two children, and other cases can be handled similarly.

Let $\mu_{1}$ and $\mu_{2}$ be the two children of $\mu$, respectively. Let $v$ be the centroid of $T(\mu)$ that is used to decompose it. We discuss the subtree $T(\mu_{1})$ first, and $T(\mu_{2})$ is similar. Since $v$ is a connector of $T(\mu_{1})$ and $T(\mu_{1})$ has at most two connectors, $T(\mu_{1})$ has at most one connector $y$ other than $v$. We consider the general situation where $T(\mu_{1})$ has such a connector $y$ (the case where such a connector does not exist can be handled similarly but in a simpler way). Note that $y$ must be a connector of $T(\mu)$.

We first compute the probability sums of $P_{i}$’s for all $i\in L(\mu)$ in the subtree $T(\mu_{1})\cup T(y,\mu)$ (e.g., see Fig. 3), which can be done in $O(|T(\mu)|)$ time by traversing $T(\mu_{1})$ and using the array $F$ and the probability list $L(y,\mu)$ at $y$, as follows. We scan the list $L(\mu)$ and for each index $i\in L(\mu)$, we reset $F[i]=0$. Then, we traverse $T(\mu_{1})$ and for each location $p_{ij}$, we update $F[i]=F[i]+f_{ij}$ (it does not matter if $i\not\in L(\mu)$). When the traversal visits $y$, we scan the list $L(y,\mu)$ and for each index $i\in L(y,\mu)$, we update $F[i]=F[i]+F(i,y,\mu)$. After the traversal, for each $i\in L(\mu)$, $F[i]$ is the probability sum of $P_{i}$ in $T(\mu_{1})\cup T(y,\mu)$. For each $i\in L(\mu)$, if $F[i]=0.5$, we report $p_{i}^{*}=v$; if $F[i]>0.5$, we add $i$ to $L(\mu_{1})$; if $F[i]<0.5$, we add $i$ to $L(\mu_{2})$. This builds the two lists $L(\mu_{1})$ and $L(\mu_{2})$, which are initially $\emptyset$. Note that since for each $i\in L(\mu)$, $P_{i}$ has at least one location in $T(\mu)$, the above way of computing $L(\mu_{1})$ (resp., $L(\mu_{2})$) guarantees that for each $i$ in $L(\mu_{1})$ (resp., $L(\mu_{2})$), $P_{i}$ has at least one location in $T(\mu_{1})$ (resp., $T(\mu_{2})$), which implies $|L(\mu_{1})|\leq|T(\mu_{1})|$ (resp., $|L(\mu_{2})|\leq|T(\mu_{2})|$).

Next we compute the probability lists for the connectors of $T(\mu_{1})$. Note that $T(\mu_{1})$ has two connectors $v$ and $y$. For $v$, we compute the probability list $L(v,\mu_{1})$ that is the same as $L(\mu_{1})$ except that each $i\in L(v,\mu_{1})$ is associated with a value $F(i,v,\mu_{1})$, which is the probability sum of $P_{i}$ in the subtree $T(v,\mu_{1})$. To compute $L(v,\mu_{1})$, we first reset $F[i]=0$ for each $i\in L(\mu_{1})$. Then we traverse $T(\mu_{2})$ and for each location $p_{ij}\in T(\mu_{2})$, we update $F[i]=F[i]+f_{ij}$. If $T(\mu_{2})$ has a connector $y^{\prime}$ other than $v$, then $y^{\prime}$ is also a connector of $T(\mu)$ (note that there is at most one such connector); we scan the probability list $L(y^{\prime},\mu)$ and for each $i\in L(y^{\prime},\mu)$, we update $F[i]=F[i]+F(i,y^{\prime},\mu)$. Finally, we scan $L(\mu_{1})$ and for each $i\in L(\mu_{1})$, we copy it to $L(v,\mu_{1})$ and set $F(i,v,\mu_{1})=F[i]$. This computes the probability list $L(v,\mu_{1})$.

Further, we also need to compute the probability list $L(y,\mu_{1})$ at $y$ for $T(\mu_{1})$. The list $L(y,\mu_{1})$ is the same as $L(\mu_{1})$ except that each $i\in L(y,\mu_{1})$ also has a value $F(i,y,\mu_{1})$, which is the probability sum of $P_{i}$ in $T(y,\mu_{1})$. To compute $L(y,\mu_{1})$, we first copy all indices of $L(\mu_{1})$ to $L(y,\mu_{1})$, and then compute the values $F(i,y,\mu_{1})$, as follows. Note that $T(y,\mu_{1})$ is exactly $T(y,\mu)$ (e.g., see Fig. 3). Recall that as a connector of $T(\mu)$, $y$ has a probability list $L(y,\mu)$ in which each $i\in L(y,\mu)$ has a value $F(i,y,\mu)$. Notice that $L(y,\mu_{1})\subseteq L(y,\mu)$. Due to $T(y,\mu_{1})=T(y,\mu)$, for each $i\in L(y,\mu_{1})$, $F(i,y,\mu_{1})$ is equal to $F(i,y,\mu)$. Since indices in each of $L(y,\mu_{1})$ and $L(y,\mu)$ are sorted, we scan $L(y,\mu_{1})$ and $L(y,\mu)$ simultaneously (like merging two sorted lists) and for each $i\in L(y,\mu_{1})$, if we encounter $i$ in $L(y,\mu)$, then we set $F(i,y,\mu_{1})=F(i,y,\mu)$. This computes the probability list $L(y,\mu_{1})$ at $y$ for $T(\mu_{1})$.

The above has processed the subtree $T(\mu_{1})$. Using the similar approach, we can process $T(\mu_{2})$ and we omit the details.

This finishes the processing of $\mu$ for the case where $\mu$ has two children. The total time is $O(|T(\mu)|)$. To see this, the algorithm traverses $T(\mu)$ for a constant number of times. The algorithm also visits the list $L(\mu)$ and the probability list of each connector of $T(\mu)$ for a constant number of times. Recall that $|L(\mu)|\leq|T(\mu)|$ and $|L(\mu)|=|L(\mu,y)|$ for each connector $y$ of $T(\mu)$. Also recall that $T(\mu)$ has at most two connectors. Thus, the total time for processing $\mu$ is $O(|T(\mu)|)$.

Remark.

If the number of connectors of $T(\mu)$ were not bounded by a constant, then we could not bound the processing time for $\mu$ as above. This is one reason our decomposition on $T$ requires each subtree $T(\mu)$ to have at most two connectors.

If $\mu$ has three children, $\mu_{1},\mu_{2},\mu_{3}$, then $T(\mu)$ is decomposed into three subtrees $T(\mu_{j})$ for $j=1,2,3$. In this case, $T(\mu)$ has two connectors. To process $\mu$, we apply the above algorithm for the two-children case twice. Specifically, we consider the procedure of decomposing $T(\mu)$ into three subtrees consisting of two “intermediate decomposition steps”. According to our decomposition, $T(\mu)$ was first decomposed into two subtrees by its centroid such that one subtree $T_{1}(\mu)$ contains at most two connectors while the other one $T_{2}(\mu)$ contains three connectors, and we consider this as the first intermediate step. The second intermediate step is to further decompose $T_{2}(\mu)$ into two subtrees each of which contains at most two connectors. To process $\mu$, we apply our two-children case algorithm on the first intermediate step and then on the second intermediate step. The total time is still $O(|T(\mu)|)$. We omit the details.

Similarly, if $\mu$ has four children, then the decomposition can be considered as consisting of three intermediate steps (e.g., in Fig. 3, the first step is to decompose $T(\mu)$ into $T_{1}(\mu)$ and $T_{2}(\mu)$, and then decomposing $T_{2}(\mu)$ into three subtrees can be considered as consisting of two steps each of which decomposes a subtree into two subtrees), and we apply our two-children case algorithm three times. The total processing time for $\mu$ is also $O(|T(\mu)|)$.

The above describes the algorithm for processing $\mu$ when $\mu$ is an internal node of $\Upsilon$.

If $\mu$ is a leaf, then $T(\mu)$ is either a vertex or an open edge of $T$. If $T(\mu)$ is an open edge, the index list $L(\mu)$ must be empty since our algorithm only finds medians on vertices. Otherwise, $T(\mu)$ is a vertex $v$ of $T$. If $L(\mu)$ is not empty, then for each $i\in L(\mu)$, we simply report $p_{i}^{*}=v$.

The running time of the entire algorithm is $O(M\log M)$. To see this, processing each node $\mu$ of $\Upsilon$ takes $O(|T(\mu)|)$ time. For each level of $\Upsilon$, the total sum of $|T(\mu)|$ of all nodes $\mu$ in the level is $O(|T|)$. Since the height of $\Upsilon$ is $O(\log M)$, the total time of the algorithm is $O(M\log M)$. This proves Lemma 1.

5 The Data Structures $\mathcal{A}_{1}$, $\mathcal{A}_{2}$, and $\mathcal{A}_{3}$

In this section, we present the three data structures $\mathcal{A}_{1}$, $\mathcal{A}_{2}$, and $\mathcal{A}_{3}$, for Lemmas 4, 5, and 6, respectively. In particular, $\mathcal{A}_{3}$ will be used to build $\mathcal{A}_{2}$ and it will also be needed for solving the $k$-center problem in Section 6. Our connector-bounded centroid decomposition $\Upsilon$ will play an important role in constructing both $\mathcal{A}_{1}$ and $\mathcal{A}_{3}$. In the following, we present them in the order of $\mathcal{A}_{1},\mathcal{A}_{3}$, and $\mathcal{A}_{2}$.

5.1 The Data Structure $\mathcal{A}_{1}$

The data structure $\mathcal{A}_{1}$ is for answering the coverage-report-queries, i.e., given any point $x\in T$, find all active uncertain points that are covered by $x$. Further, it also supports the operation of removing an uncertain point once it is deactivated.

Consider any node $\mu\in\Upsilon$. If $\mu$ is the root, let $L(\mu)=\emptyset$; otherwise, define $L(\mu)$ to be the sorted list of all indices $i\in[1,n]$ such that $P_{i}$ does not have any locations in the subtree $T(\mu)$ but has at least one location in $T(\mu^{\prime})$, where $\mu^{\prime}$ is the parent of $\mu$. Let $y$ be any connector of $T(\mu)$. Let $L(y,\mu)$ be an index list the same as $L(\mu)$ and each index $i\in L(y,\mu)$ is associated with two values: $F(i,y,\mu)$, which is the probability sum of $P_{i}$ in the subtree $T(y,\mu)$, and $D(i,y,\mu)$, which is the expected distance from $y$ to the locations of $P_{i}$ in $T(y,\mu)$, i.e., $D(i,y,\mu)=w_{i}\cdot\sum_{p_{ij}\in T(y,\mu)}f_{ij}\cdot d(p_{ij},y)$. We refer to $L(\mu)$ and $L(y,\mu)$ for each connector $y\in T(\mu)$ as the information lists of $\mu$.

Lemma 9

Suppose $L(\mu)\neq\emptyset$ and the information lists of $\mu$ are available. Let $t_{\mu}$ be the number of indices in $L(\mu)$. Then, we can build a data structure of $O(t_{\mu})$ size in $O(|T(\mu)|+t_{\mu}\log t_{\mu})$ time on $T(\mu)$, such that given any point $x\in T(\mu)$, we can report all indices $i$ of $L(\mu)$ such that $P_{i}$ is covered by $x$ in $O(\log n+k\log n)$ amortized time, where $k$ is the output size; further, if $P_{i}$ is deactivated with $i\in L(\mu)$, then we can remove $i$ from the data structure and all information lists of $\mu$ in $O(\log n)$ amortized time.

Proof

As $L(\mu)\neq\emptyset$, $\mu$ is not the root. Thus, $T(\mu)$ has one or two connectors. We only discuss the most general case where $T(\mu)$ has two connectors since the other case is similar but easier. Let $y_{1}$ and $y_{2}$ denote the two connectors of $T(\mu)$, respectively. So the lists $L(y_{1},\mu)$ and $L(y_{2},\mu)$ are available.

Note that for any two points $p$ and $q$ in $T(\mu)$, $\pi(p,q)$ is also in $T(\mu)$ since $T(\mu)$ is connected.

Consider any point $x\in T(\mu)$. Suppose we traverse on $T(\mu)$ from $x$ to $y_{1}$, and let $q_{x}$ be the first point on $\pi(y_{1},y_{2})$ we encounter (e.g. see Fig 4; so $q_{x}$ is $x$ if $x\in\pi(y_{1},y_{2})$). Let $a_{x}=d(x,q_{x})$ and $b_{x}=d(q_{x},y_{1})$. Thus, $d(y_{1},x)=a_{x}+b_{x}$ and $d(y_{2},x)=a_{x}+d(y_{1},y_{2})-b_{x}$.

For any $i\in L(\mu)$, since $P_{i}$ does not have any location in $T(\mu)$, we have $F(i,y_{1},\mu)+F(i,y_{2},\mu)=1$, and thus the following holds for $\mathsf{E}\mathrm{d}(x,P_{i})$:

[TABLE]

Notice that for any $x\in T(\mu)$, all above values are constant except $a_{x}$ and $b_{x}$. Therefore, if we consider $a_{x}$ and $b_{x}$ as two variables of $x$, $\mathsf{E}\mathrm{d}(x,P_{i})$ is a linear function of them. In other words, $\mathsf{E}\mathrm{d}(x,P_{i})$ defines a plane in $\mathbb{R}^{3}$, where the $z$-coordinates correspond to the values of $\mathsf{E}\mathrm{d}(x,P_{i})$ and the $x$- and $y$-coordinates correspond to $a_{x}$ and $b_{x}$ respectively. In the following, we also use $\mathsf{E}\mathrm{d}(x,P_{i})$ to refer to the plane defined by it in $\mathbb{R}^{3}$.

Remark.

This nice property for calculating $\mathsf{E}\mathrm{d}(x,P_{i})$ is due to that $\mu$ has at most two connectors. This is another reason our decomposition requires every subtree $T(\mu)$ to have at most two connectors.

Recall that $x$ covers $P_{i}$ if $\mathsf{E}\mathrm{d}(x,P_{i})\leq\lambda$. Consider the plane $H_{\lambda}:z=\lambda$ in $\mathbb{R}^{3}$. In general the two planes $\mathsf{E}\mathrm{d}(x,P_{i})$ and $H_{\lambda}$ intersect at a line $l_{i}$ and we let $h_{i}$ represent the closed half-plane of $H_{\lambda}$ bounded by $l_{i}$ and above the plane $\mathsf{E}\mathrm{d}(x,P_{i})$. Let $x_{\lambda}$ be the point $(a_{x},b_{x})$ in the plane $H_{\lambda}$. An easy observation is that $\mathsf{E}\mathrm{d}(x,P_{i})\leq\lambda$ if and only if $x_{\lambda}\in h_{i}$. Further, we say that $l_{i}$ is an upper bounding line of $h_{i}$ if $h_{i}$ is below $l_{i}$ and a lower bounding line otherwise. Observe that if $l_{i}$ is an upper bounding line, then $\mathsf{E}\mathrm{d}(x,P_{i})\leq\lambda$ if and only if $x_{\lambda}$ is below $l_{i}$; if $l_{i}$ is a lower bounding line, then $\mathsf{E}\mathrm{d}(x,P_{i})\leq\lambda$ if and only if $x_{\lambda}$ is above $l_{i}$.

Given any query point $x\in T(\mu)$, our goal for answering the query is to find all indices $i\in L(\mu)$ such that $P_{i}$ is covered by $x$. Based on the above discussions, we do the following preprocessing. After $d(y_{1},y_{2})$ is computed, by using the information lists of $y_{1}$ and $y_{2}$, we compute all functions $\mathsf{E}\mathrm{d}(x,P_{i})$ for all $i\in L(\mu)$ in $O(t_{\mu})$ time. Then, we obtain a set $U$ of all upper bounding lines and a set of all lower bounding lines on the plane $H_{\lambda}$ defined by $\mathsf{E}\mathrm{d}(x,P_{i})$ for all $i\in L(\mu)$. In the following, we first discuss the upper bounding lines. Let $S_{U}$ denote the indices $i\in L(\mu)$ such that $P_{i}$ defines an upper bounding line in $U$.

Given any point $x\in T(\mu)$, we first compute $a_{x}$ and $b_{x}$. This can be done in constant time after $O(|T(\mu)|)$ time preprocessing, as follows. In the preprocessing, for each vertex $v$ of $T(\mu)$, we compute the vertex $q_{v}$ (defined in the similar way as $q_{x}$ with respect to $x$) as well as the two values $a_{v}$ and $b_{v}$ (defined similarly as $a_{x}$ and $b_{x}$, respectively). This can be easily done in $O(|T(\mu)|)$ time by traversing $T(\mu)$ and we omit the details. Given the point $x$, which is specified by an edge $e$ containing $x$, let $v$ be the incident vertex of $e$ closer to $y_{1}$ and let $\delta$ be the length of $e$ between $v$ and $x$. Then, if $e$ is on $\pi(y_{1},y_{2})$, we have $a_{x}=0$ and $b_{x}=b_{v}+\delta$. Otherwise, $a_{x}=a_{v}+\delta$ and $b_{x}=b_{v}$.

After $a_{x}$ and $b_{x}$ are computed, the point $x_{\lambda}=(a_{x},b_{x})$ on the plane $H_{\lambda}$ is also obtained. Then, according to our discussion, all uncertain points of $S_{U}$ that are covered by $x$ correspond to exactly those lines of $U$ above $x_{\lambda}$. Finding the lines of $U$ above $x_{\lambda}$ is actually the dual problem of half-plane range reporting query in $\mathbb{R}^{2}$. By using the dynamic convex hull maintenance data structure of Brodal and Jacob [10], with $O(|U|\log|U|)$ time and $O(|U|)$ space preprocessing, for any point $x_{\lambda}$, we can easily report all lines of $U$ above $x_{\lambda}$ in $O(\log|U|+k\log|U|)$ amortized time (i.e., by repeating $k$ deletions), where $k$ is the output size, and deleting a line from $U$ can be done in $O(\log|U|)$ amortized time. Clearly, $|U|\leq t_{\mu}$.

On the set of all lower bounding lines, we do the similar preprocessing, and the query algorithm is symmetric.

Hence, the total preprocessing time is $O(|T(\mu)|+t_{\mu}\log t_{\mu})$ time. Each query takes $O(\log t_{\mu}+k\log^{2}t_{\mu})$ amortized time and each remove operation can be performed in $O(\log t_{\mu})$ amortized time. Note that $t_{\mu}\leq n$. The lemma thus follows. ∎

The preprocessing algorithm for our data structure $\mathcal{A}_{1}$ consists of the following four steps. First, we compute the information lists for all nodes $\mu$ of $\Upsilon$. Second, for each node $\mu\in\Upsilon$, we compute the data structure of Lemma 9. Third, for each $i\in[1,n]$, we compute a node list $L_{\mu}(i)$ containing all nodes $\mu\in\Upsilon$ such that $i\in L(\mu)$. Fourth, for each leaf $\mu$ of $\Upsilon$, if $T(\mu)$ is a vertex $v$ of $T$ holding a location $p_{ij}$, then we maintain at $\mu$ the value $\mathsf{E}\mathrm{d}(v,P_{i})$. Before giving the details of the above processing algorithm, we first assume the preprocessing work has been done and discuss the algorithm for answering the coverage-report-queries.

Given any point $x\in T$, we answer the coverage-report-query as follows. Note that $x$ is in $T(\mu_{x})$ for some leaf $\mu_{x}$ of $\Upsilon$. For each node $\mu$ in the path of $\Upsilon$ from the root to $\mu_{x}$, we apply the query algorithm in Lemma 9 to report all indices $i\in L(\mu)$ such that $x$ covers $P_{i}$. In addition, if $T(\mu_{x})$ is a vertex of $T$ holding a location $p_{ij}$ such that $P_{i}$ is active, then we report $i$ if $\mathsf{E}\mathrm{d}(v,P_{i})$, which is maintained at $v$, is at most $\lambda$. The following lemma proves the correctness and the performance of our query algorithm.

Lemma 10

Our query algorithm correctly finds all active uncertain points that are covered by $x$ in $O(\log M\log n+k\log n)$ amortized time, where $k$ is the output size.

Proof

Let $\pi_{x}$ represent the path of $\Upsilon$ from the root to the leaf $\mu_{x}$. To show the correctness of the algorithm, we argue that for each active uncertain point $P_{i}$ that is covered by $x$, $i$ will be reported by our query algorithm.

Indeed, if $T(\mu_{x})$ is a vertex $v$ of $T$ holding a location $p_{ij}$ of $P_{i}$, then the leaf $\mu_{x}$ maintains the value $\mathsf{E}\mathrm{d}(v,P_{i})$, which is equal to $\mathsf{E}\mathrm{d}(x,P_{i})$ as $x=v$. Hence, our algorithm will report $i$ when it processes $\mu_{x}$. Otherwise, no location of $P_{i}$ is in $T(\mu_{x})$. Since $P_{i}$ has locations in $T$, if we go from the root to $\mu_{x}$ along $\pi$, we will eventually meet a node $\mu$ such that $T(\mu)$ does not have any location of $P_{i}$ while $T(\mu^{\prime})$ has at least one location of $P_{i}$, where $\mu^{\prime}$ is the parent of $\mu$. This implies that $i$ is in $L(\mu)$, and consequently, our query algorithm will report $i$ when it processes $\mu$. This establishes the correctness of our query algorithm.

For the runtime, as the height of $\Upsilon$ is $O(\log M)$, we make $O(\log M)$ calls on the query algorithm in Lemma 9. Further, notice that each $i$ will be reported at most once. This is because if $i$ is in $L(\mu)$ for some node $\mu$, then $i$ cannot be in $L(\mu^{\prime})$ for any ancestor $\mu^{\prime}$ of $\mu$. Therefore, the total runtime is $O(\log M\log n+k\log n)$. ∎

If an uncertain point $P_{i}$ is deactivated, then we scan the node list $L_{\mu}(i)$ and for each node $\mu\in L_{\mu}(i)$, we remove $i$ from the data structure by Lemma 9. The following lemma implies that the total time is $O(m_{i}\log M\log n)$.

Lemma 11

For each $i\in[1,n]$, the number of nodes in $L_{\mu}(i)$ is $O(m_{i}\log M)$.

Proof

Let $\alpha$ denote the number of nodes of $L_{\mu}(i)$. Our goal is to argue that $i$ appears in $L(\mu)$ for $O(m_{i}\log M)$ nodes $\mu$ of $\Upsilon$. Recall that if $i$ is in $L(\mu)$ for a node $\mu\in\Upsilon$, then $P_{i}$ has at least one location in $T(\mu^{\prime})$, where $\mu^{\prime}$ is the parent of $\mu$. Since each node of $\Upsilon$ has at most four children, if $N$ is the total number of nodes $\mu^{\prime}$ such that $P_{i}$ has at least one location in $T(\mu^{\prime})$, then it holds that $\alpha\leq 4N$. Below we show that $N=O(m_{i}\log M)$, which will prove the lemma.

Consider any location $p_{ij}$ of $P_{i}$. According to our decomposition, the subtrees $T(\mu)$ for all nodes $\mu$ in the same level of $\Upsilon$ are pairwise disjoint. Let $v$ be the vertex of $T$ that holds $p_{ij}$, and let $\mu_{v}$ be the leaf of $\Upsilon$ with $T(\mu_{v})=v$. Observe that for any node $\mu\in\Upsilon$, $p_{ij}$ appears in $T(\mu)$ if and only if $\mu$ is in the path of $\Upsilon$ from $\mu_{v}$ to the root. Hence, there are $O(\log M)$ nodes $\mu\in\Upsilon$ such that $p_{ij}$ appears in $T(\mu)$. As $P_{i}$ has $m_{i}$ locations, we obtain $N=O(m_{i}\log M)$. ∎

The following lemma gives our preprocessing algorithm for building $\mathcal{A}_{1}$.

Lemma 12

$\sum_{\mu\in\Upsilon}t_{\mu}=O(M\log M)$, and the preprocessing time for constructing the data structure $\mathcal{A}_{1}$ excluding the second step is $O(M\log M)$.

Proof

We begin with the first step of the preprocessing algorithm for $\mathcal{A}_{1}$, i.e., computing the information lists for all nodes $\mu$ of $\Upsilon$.

In order to do so, for each node $\mu\in\Upsilon$, we will also compute a sorted list $L^{\prime}(\mu)$ of all such indices $i\in[1,n]$ that $P_{i}$ has at least one location in $T(\mu)$, and further, for each connector $y$ of $T(\mu)$, we will compute a list $L^{\prime}(y,\mu)$ that is the same as $L^{\prime}(\mu)$ except that each $i\in L^{\prime}(y,\mu)$ is associated with two values: $F(i,y,\mu)$, which is equal to the probability sum of $P_{i}$ in the subtree $T(y,\mu)$, and $D(i,y,\mu)$, which is equal to the expected distance from $y$ to the locations of $P_{i}$ in $T(y,\mu)$, i.e., $D(i,y,\mu)=w_{i}\cdot\sum_{p_{ij}\in T(y,\mu)}f_{ij}\cdot d(y,p_{ij})$. With a little abuse of notation, we call all above the information lists of $\mu$ (including its original information lists). In the following, we describe our algorithm for computing the information lists of all nodes $\mu$ of $\Upsilon$. Let $F[1\cdots n]$ and $D[1\cdots n]$ be two arrays that we are going to use in our algorithm (they will mostly be used to compute the $F$ values and $D$ values of the information lists of connectors).

Initially, if $\mu$ is the root of $\Upsilon$, we have $L^{\prime}(\mu)=\{1,2,\ldots,n\}$ and $L(\mu)=\emptyset$. Since $T(\mu)$ does not have any connectors, we do not need to compute the information lists for connectors.

Consider any internal node $\mu$. We assume all information lists for $\mu$ has been computed (i.e., $L(\mu)$, $L^{\prime}(\mu)$, and $L^{\prime}(y,\mu)$, $L(y,\mu)$ for each connector $y$ of $T(\mu)$). In the following we present our algorithm for processing $\mu$, which will compute the information lists of all children of $\mu$ in $O(|T(\mu)|)$ time.

We first discuss the case where $\mu$ has two children, denoted by $\mu_{1}$ and $\mu_{2}$, respectively. Let $v$ be the centroid of $T(\mu)$ that is used to decompose $T(\mu)$ into $T(\mu_{1})$ and $T(\mu_{2})$ (e.g., see Fig. 5). We first compute the information lists of $\mu_{1}$, as follows.

We begin with computing the two lists $L(\mu_{1})$ and $L^{\prime}(\mu_{1})$. Initially, we set both of them to $\emptyset$. We scan the list $L^{\prime}(\mu)$ and for each $i\in L^{\prime}(\mu)$, we reset $F[i]=0$. Then, we scan the subtree $T(\mu_{1})$, and for each location $p_{ij}$, we set $F[i]=1$ as a flag showing that $P_{i}$ has locations in $T(\mu_{1})$. Afterwards, we scan the list $L^{\prime}(\mu)$ again, and for each $i\in L^{\prime}(\mu)$, if $F[i]=1$, then we add $i$ to $L^{\prime}(\mu_{1})$; otherwise, we add $i$ to $L(\mu_{1})$. This computes the two index lists $L(\mu_{1})$ and $L^{\prime}(\mu_{1})$ for $\mu_{1}$. The running time is $O(|T(\mu)|)$ since the size of $L^{\prime}(\mu)$ is no more than $|T(\mu)|$.

We proceed to compute the information lists for the connectors of $T(\mu_{1})$. Recall that $v$ is a connector of $T(\mu_{1})$. So we need to compute the two lists $L(v,\mu_{1})$ and $L^{\prime}(v,\mu_{1})$, such that each index $i$ in either list is associated with the two values $F(i,v,\mu_{1})$ and $D(i,v,\mu_{1})$. We first copy all indices of $L(\mu_{1})$ to $L(v,\mu_{1})$ and copy all indices of $L^{\prime}(\mu_{1})$ to $L^{\prime}(v,\mu_{1})$. Next we compute their $F$ and $D$ values as follows.

We first scan $L^{\prime}(\mu)$ and for each $i\in L^{\prime}(\mu)$, we reset $F[i]=0$ and $D[i]=0$. Next, we traverse $T(\mu_{2})$ and for each location $p_{ij}$, we update $F[i]=F[i]+f_{ij}$ and $D[i]=D[i]+w_{i}\cdot f_{ij}\cdot d(v,p_{ij})$ ($d(v,p_{ij})$ can be computed in constant time after $O(T(\mu))$-time preprocessing that computes $d(v,v^{\prime})$ for every vertex $v^{\prime}\in T(\mu)$ by traversing $T(\mu)$). Further, if $T(\mu_{2})$ has a connector $y$ other than $v$, then $y$ must be a connector of $T(\mu)$ (e.g., see Fig. 5; there exists at most one such connector $y$); we scan the list $L^{\prime}(y,\mu_{2})$, and for each $i\in L^{\prime}(y,\mu_{2})$, we update $F[i]=F[i]+F(i,y,\mu)$ and $D[i]=D[i]+D(i,y,\mu)+w_{i}\cdot d(v,y)\cdot F(i,y,\mu)$ ($d(v,y)$ is already computed in the preprocessing discussed above). Finally, we scan $L(v,\mu_{1})$ (resp., $L^{\prime}(v,\mu_{1})$) and for each index $i$ in $L(v,\mu_{1})$ (resp., $L^{\prime}(v,\mu_{1})$), we set $F(i,v,\mu_{1})=F[i]$ and $D(i,v,\mu_{1})=D[i]$. This computes the two information lists $L(v,\mu_{1})$ and $L^{\prime}(v,\mu_{1})$. The total time is $O(|T(\mu)|)$.

In addition, if $T(\mu_{1})$ has a connector $y$ other than $v$, then $y$ must be a connector of $T(\mu)$ (e.g., see Fig. 3; there is only one such connector), and we further compute the two information lists $L(y,\mu_{1})$ and $L^{\prime}(y,\mu_{1})$. To do so, we first copy all indices of $L(\mu_{1})$ to $L(y,\mu_{1})$ and copy all indices of $L^{\prime}(\mu_{1})$ to $L^{\prime}(y,\mu_{1})$. Observe that $L(y,\mu_{1})$ and $L^{\prime}(y,\mu_{1})$ form a partition of the indices of $L^{\prime}(y,\mu)$. For each index $i$ in $L(y,\mu_{1})$ (resp., $L^{\prime}(y,\mu_{1})$), we have $F(i,y,\mu_{1})=F(i,y,\mu)$ and $D(i,y,\mu_{1})=D(i,y,\mu)$. Therefore, the $F$ and $D$ values for $L^{\prime}(y,\mu_{1})$ and $L(y,\mu_{1})$ can be obtained from $L^{\prime}(y,\mu)$ by scanning the three lists $L^{\prime}(y,\mu_{1})$, $L(y,\mu_{1})$, and $L^{\prime}(y,\mu)$ simultaneously, as they are all sorted lists.

The above has computed the information lists for $\mu_{1}$ and the total time is $O(|T(\mu)|)$. Using the similar approach, we can compute the information lists for $\mu_{2}$, and we omit the details. This finishes the algorithm for processing $\mu$ where $\mu$ has two children.

If $\mu$ has three children, then $T(\mu)$ is decomposed into three subtrees in our decomposition. As discussed in Section 4.2 on the algorithm for Lemma 1, we can consider the decomposition of $T(\mu)$ consisting of two intermediate decomposition steps each of which decompose a subtree into two subtrees. For each intermediate step, we apply the above processing algorithm for the two-children case. In this way, we can compute the information lists for all three children of $\mu$ in $O(|T(\mu)|)$ time. If $\mu$ has four children, then similarly there are four intermediate decomposition steps and we apply the two-children case algorithm three times. The total processing time for $\mu$ is still $O(|T(\mu)|)$.

Once all internal nodes of $\Upsilon$ are processed, the information lists of all nodes are computed. Since processing each node $\mu$ of $\Upsilon$ takes $O(|T(\mu)|)$ time, the total time of the algorithm is $O(M\log M)$. This also implies that the total size of the information lists of all nodes of $\Upsilon$ is $O(M\log M)$, i.e., $\sum_{\mu\in\Upsilon}t_{\mu}=O(M\log M)$.

This above describes the first step of our preprocessing algorithm for $\mathcal{A}_{1}$. For the third step, the node lists $L_{\mu}(i)$ can be built during the course of the above algorithm. Specifically, whenever an index $i$ is added to $L(\mu)$ for some node $\mu$ of $\Upsilon$, we add $\mu$ to the list $L_{\mu}(i)$. This only introduces constant extra time each. Therefore, the overall algorithm has the same runtime asymptotically as before.

For the fourth step, for each leaf $\mu$ of $\Upsilon$ such that $T(\mu)$ is a vertex $v$ of $T$, we do the following. Let $p_{ij}$ be the uncertain point location at $v$. Based on our above algorithm, we have $L^{\prime}(\mu)=\{i\}$. Since $v$ is a connector, we have a list $L^{\prime}(v,\mu)$ consisting of $i$ itself and two values $F(i,v,\mu)$ and $D(i,v,\mu)$. Notice that $\mathsf{E}\mathrm{d}(v,P_{i})=D(i,v,\mu)$. Hence, once the above algorithm finishes, the value $\mathsf{E}\mathrm{d}(v,P_{i})$ is available.

As a summary, the preprocessing algorithm for $\mathcal{A}_{1}$ except the second step runs in $O(M\log M)$ time. The lemma thus follows. ∎

For the second step of the preprocessing of $\mathcal{A}_{1}$, since $\sum_{\mu\in\Upsilon}t_{\mu}=O(M\log M)$ by Lemma 12, applying the preprocessing algorithm of Lemma 9 on all nodes of $\Upsilon$ takes $O(M\log^{2}M)$ time and $O(M\log M)$ space in total. Hence, the total preprocessing time of $\mathcal{A}_{1}$ is $O(M\log^{2}M)$ and the space is $O(M\log M)$. This proves Lemma 4.

5.2 The Data Structure $\mathcal{A}_{3}$

In this section, we present the data structure $\mathcal{A}_{3}$. Given any point $x$ and any uncertain point $P_{i}$, $\mathcal{A}_{3}$ is used to compute the expected distance $\mathsf{E}\mathrm{d}(x,P_{i})$. Note that we do not need to consider the remove operations for $\mathcal{A}_{3}$.

We follow the notation defined in Section 5.1. As preprocessing, for each node $\mu\in\Upsilon$, we compute the information lists $L(\mu)$ and $L(y,\mu)$ for each connector $y$ of $T(\mu)$. This is actually the first step of the preprocessing algorithm of $\mathcal{A}_{1}$ in Section 5.1. Further, we also preform the fourth step of the preprocessing algorithm for $\mathcal{A}_{1}$. The above can be done in $O(M\log M)$ time by Lemma 12.

Consider any node $\mu\in\Upsilon$ with $L(\mu)\neq\emptyset$. Given any point $x\in T(\mu)$, we have shown in the proof of Lemma 9 that $\mathsf{E}\mathrm{d}(x,P_{i})$ is a function of two variables $a_{x}$ and $b_{x}$. As preprocessing, we compute these functions for all $i\in L(\mu)$, which takes $O(t_{\mu})$ time as shown in the proof of Lemma 9. For each $i\in L(\mu)$, we store the function $\mathsf{E}\mathrm{d}(x,P_{i})$ at $\mu$. The total preprocessing time for $\mathcal{A}_{3}$ is $O(M\log M)$.

Consider any query on a point $x\in T$ and $P_{i}\in\mathcal{P}$. Note that $x$ is specified by an edge $e$ and its distance to a vertex of $e$. Let $\mu_{x}$ be the leaf of $\Upsilon$ with $x\in T(\mu_{x})$. If $x$ is in the interior of $e$, then $T(\mu_{x})$ is the open edge $e$; otherwise, $T(\mu_{x})$ is a single vertex $v=x$.

We first consider the case where $x$ is in the interior of $e$. In this case, $P_{i}$ does not have any location in $T(\mu_{x})$ since $T(\mu_{x})$ is an open edge. Hence, if we go along the path of $\Upsilon$ from the root to $\mu_{x}$, we will encounter a first node $\mu^{\prime}$ with $i\in L(\mu^{\prime})$. After finding $\mu^{\prime}$, we compute $a_{x}$ and $b_{x}$ in $T(\mu^{\prime})$, which can be done in constant time after $O(|T(\mu^{\prime})|)$ time preprocessing on $T(\mu^{\prime})$, as discussed in the proof of Lemma 9 (so the total preprocessing time for all nodes of $\Upsilon$ is $O(M\log M)$). After $a_{x}$ and $b_{x}$ are computed, we can obtain the value $\mathsf{E}\mathrm{d}(x,P_{i})$.

Remark.

One can verify (from the proof of Lemma 9) that as $x$ changes on $e$, $\mathsf{E}\mathrm{d}(x,P_{i})$ is a linear function of $x$ because one of $a_{x}$ and $b_{x}$ is constant and the other linearly changes as $x$ changes in $e$. Hence, the above also computes the linear function $\mathsf{E}\mathrm{d}(x,P_{i})$ for $x\in e$.

To find the above node $\mu^{\prime}$, for each node $\mu$ in the path of $\Upsilon$ from the root to $\mu_{x}$, we need to determine whether $i\in L(\mu)$. If we represented the sorted index list $L(\mu)$ by a binary search tree, then we could spend $O(\log n)$ time on each node $\mu$ and thus the total query time would be $O(\log n\log M)$. To remove the $O(\log n)$ factor, we further enhance our preprocessing work by building a fractional cascading structure [12] on the sorted index lists $L(\mu)$ for all nodes $\mu$ of $\Upsilon$. The total preprocessing time for building the structure is linear in the total number of nodes of all lists, which is $O(M\log M)$ by Lemma 12. For each node $\mu$, the fractional cascading structure will create a new list $L^{*}(\mu)$ such that $L(\mu)\subseteq L^{*}(\mu)$. Further, for each index $i\in L^{*}(\mu)$, if it is also in $L(\mu)$, then we set a flag as an indicator. Setting the flags for all nodes of $\Upsilon$ can be done in $O(M\log M)$ time as well. Using the fractional cascading structure, we only need to do binary search on the list in the root and then spend constant time on each subsequent node [12], and thus the total query time is $O(\log M)$.

If $x$ is a vertex $v$ of $T$, then depending on whether the location at $v$ is $P_{i}$’s or not, there are two subcases. If it is not, then we apply the same query algorithm as above. Otherwise, let $p_{ij}$ be the location at $v$. Recall that in our preprocessing, the value $\mathsf{E}\mathrm{d}(v,P_{i})$ has already been computed and stored at $\mu_{x}$ as $T(\mu_{x})=v$. Due to $v=x$, we obtain $\mathsf{E}\mathrm{d}(x,P_{i})=\mathsf{E}\mathrm{d}(v,P_{i})$.

Hence, in either case, the query algorithm runs in $O(\log M)$ time. This proves Lemma 6.

5.3 The Data Structure $\mathcal{A}_{2}$

The data structure $\mathcal{A}_{2}$ is for answering candidate-center-queries: Given any vertex $v\in T_{m}$, the query asks for the candidate center $c$ for the active medians in $T_{m}(v)$, which is the subtree of $T_{m}$ rooted at $v$. Once an uncertain point is deactivated, $\mathcal{A}_{2}$ can also support the operation of removing it.

Consider any vertex $v\in T_{m}$. Recall that due to our reindexing, the indices of all medians in $T_{m}(v)$ exactly form the range $R(v)$. Recall that the candidate center $c$ is the point on the path $\pi(v,r)$ closest to $r$ with $\mathsf{E}\mathrm{d}(v,P_{i})\leq\lambda$ for each active uncertain point $P_{i}$ with $i\in R(v)$. Also recall that our algorithm invariant guarantees that whenever a candidate-center-query is called at a vertex $v$, then it holds that $\mathsf{E}\mathrm{d}(v,P_{i})\leq\lambda$ for each active uncertain point $P_{i}$ with $i\in R(v)$. However, we actually give a result that can answer a more general query. Specifically, given a range $[k,j]$ with $1\leq k\leq j\leq n$, let $v_{kj}$ be the lowest common ancestor of all medians $p_{i}^{*}$ with $i\in[k,j]$ in $T_{m}$; if $\mathsf{E}\mathrm{d}(v_{kj},P_{i})>\lambda$ for some active $P_{i}$ with $i\in[k,j]$, then our query algorithm will return $\emptyset$; otherwise, our algorithm will compute a point $c$ on $\pi(v_{kj},r)$ closest to $r$ with $\mathsf{E}\mathrm{d}(c,P_{i})\leq\lambda$ for each active $P_{i}$ with $i\in[k,j]$. We refer to it as the generalized candidate-center-query.

In the preprocessing, we build a complete binary search tree $\mathcal{T}$ whose leaves from left to right correspond to indices $1,2,\ldots,n$. For each node $u$ of $\mathcal{T}$, let $R(u)$ denote the set of indices corresponding to the leaves in the subtree of $\mathcal{T}$ rooted at $u$. For each median $p_{i}^{*}$, define $q_{i}$ to be the point $x$ on the path $\pi(p_{i}^{*},r)$ of $T_{m}$ closest to $r$ with $\mathsf{E}\mathrm{d}(x,P_{i})\leq\lambda$.

For each node $u$ of $\mathcal{T}$, we define a node $q(u)$ as follows. If $u$ is a leaf, define $q(u)$ to be $q_{i}$, where $i$ is the index corresponding to leaf $u$. If $u$ is an internal node, let $v_{u}$ denote the vertex of $T_{m}$ that is the lowest common ancestor of the medians $p_{i}^{*}$ for all $i\in R(u)$. If $\mathsf{E}\mathrm{d}(v_{u},P_{i})\leq\lambda$ for all $i\in R(u)$ (or equivalently, $q_{i}$ is in $\pi(v_{u},r)$ for all $i\in R(u)$), then define $q(u)$ to be the point $x$ on the path $\pi(v_{u},r)$ of $T_{m}$ closest to $r$ with $\mathsf{E}\mathrm{d}(x,P_{i})\leq\lambda$ for all $i\in R(u)$; otherwise, $q(u)=\emptyset$.

Lemma 13

The points $q(u)$ for all nodes $u\in\mathcal{T}$ can be computed in $O(M\log M+n\log^{2}M)$ time.

Proof

Assume the data structure $\mathcal{A}_{3}$ for Lemma 6 has been computed in $O(M\log M)$ time. In the following, by using $\mathcal{A}_{3}$ we compute $q(u)$ for all nodes $u\in\mathcal{T}$ in $O(M+n\log^{2}M)$ time.

We first compute $q_{i}$ for all medians $p_{i}^{*}$. Consider the depth-first-search on $T_{m}$ starting from the root $r$. During the traversal, we use a stack $S$ to maintain all vertices in order along the path $\pi(r,v)$ whenever a vertex $v$ is visited. Such a stack can be easily maintained by standard techniques (i.e., push new vertices into $S$ when we go “deeper” and pop vertices out of $S$ when backtrack), without affecting the linear-time performance of the traversal asymptotically. Suppose the traversal visits a median $p_{i}^{*}$. Then, the vertices of $S$ essentially form the path $\pi(r,p_{i}^{*})$. To compute $q_{i}$, we do binary search on the vertices of $S$, as follows.

We implement $S$ by using an array of size $M$. Since the order of the vertices of $S$ is the same as their order along $\pi(r,p_{i}^{*})$, the expected distances $\mathsf{E}\mathrm{d}(v,P_{i})$ of the vertices $v\in S$ along their order in $S$ are monotonically changing. Consider a middle vertex $v$ of $S$. The vertex $v$ partitions $S$ into two subarrays such that one subarray contains all vertices of $\pi(r,v)$ and the other contains vertices of $\pi(v,p_{i}^{*})$. We compute $\mathsf{E}\mathrm{d}(v,P_{i})$ by using data structure $\mathcal{A}_{3}$. Depending on whether $\mathsf{E}\mathrm{d}(v,P_{i})\leq\lambda$, we can proceed on only one subarray of $M$. The binary search will eventually locate an edge $e=(v,v^{\prime})$ such that $\mathsf{E}\mathrm{d}(v,P_{i})\leq\lambda$ and $\mathsf{E}\mathrm{d}(v^{\prime},P_{i})>\lambda$. Then, we know that $q_{i}$ is located on $e\setminus\{v^{\prime}\}$. We further pick any point $x$ in the interior of $e$ and the data structure $\mathcal{A}_{3}$ can also compute the function $\mathsf{E}\mathrm{d}(x,P_{i})$ for $x\in e$ as remarked in Section 5.2. With the function $\mathsf{E}\mathrm{d}(x,P_{i})$ for $x\in e$, we can compute $q_{i}$ in constant time. Since the binary search calls $\mathcal{A}_{3}$ $O(\log M)$ times, the total time of the binary search is $O(\log^{2}M)$.

In this way, we can compute $q_{i}$ for all medians $p_{i}^{*}$ with $i\in[1,n]$ in $O(M+n\log^{2}M)$ time, where the $O(n\log^{2}M)$ time is for the binary search procedures in the entire algorithm and the $O(M)$ time is for traversing the tree $T_{m}$. Note that this also computes $q(u)$ for all leaves $u$ of $\mathcal{T}$.

We proceed to compute the points $q(u)$ for all internal nodes $\mu$ of $\mathcal{T}$ in a bottom-up manner. Consider an internal node $u$ such that $q(u_{1})$ and $q(u_{2})$ have been computed, where $u_{1}$ and $u_{2}$ are the children of $u$, respectively. We compute $q(u)$ as follows.

If either one of $q(u_{1})$ and $q(u_{2})$ is $\emptyset$, then we set $q(u)=\emptyset$. Otherwise, we do the following. Let $i$ (resp., $j$) be the leftmost (resp., rightmost) leaf in the subtree $\mathcal{T}(u)$ of $\mathcal{T}$ rooted at $u$. We first find the lowest comment ancestor of $p_{i}^{*}$ and $p_{j}^{*}$ in the tree $T_{m}$, denoted by $v_{ij}$. Due to our particular way of defining indices of all medians, $v_{ij}$ is the lowest common ancestor of the medians $p_{k}^{*}$ for all $k\in[i,j]$. We determine whether $q(u_{1})$ and $q(u_{2})$ are both on $\pi(r,v_{ij})$. If either one is not on $\pi(r,v_{ij})$, then we set $q(u)=\emptyset$; otherwise, we set $q(u)$ to the one of $q(u_{1})$ and $q(u_{2})$ closer to $v_{ij}$.

The above for computing $q(u)$ can be implemented in $O(1)$ time, after $O(M)$ time preprocessing on $T_{m}$. Specifically, with $O(M)$ time preprocessing on $T_{m}$, given any two vertices of $T_{m}$, we can compute their lowest common ancestor in $O(1)$ time [7, 21]. Hence, we can compute $v_{ij}$ in constant time. To determine whether $q(u_{1})$ is on $\pi(r,v_{ij})$, we use the following approach. As a point on $T_{m}$, $q(u_{1})$ is specified by an edge $e_{1}$ and its distance to one incident vertex of $e_{1}$. Let $v_{1}$ be the incident vertex of $e_{1}$ that is farther from the root $r$. Observe that $q(u_{1})$ is on $\pi(r,v_{ij})$ if and only if the lowest common ancestor of $v_{1}$ and $v_{ij}$ is $v_{1}$. Hence, we can determine whether $q(u_{1})$ is on $\pi(r,v_{ij})$ in constant time by a lowest common ancestor query. Similarly, we can determine whether $q(u_{2})$ is on $\pi(r,v_{ij})$ in constant time. Assume both $q(u_{1})$ and $q(u_{2})$ are on $\pi(r,v_{ij})$. To determine which one of $q(u_{1})$ and $q(u_{2})$ is closer to $v_{ij}$, if they are on the same edge $e$ of $T_{m}$, then this can be done in constant time since both points are specified by their distances to an incident vertex of $e$. Otherwise, let $e_{1}$ be the edge of $T_{m}$ containing $q(u_{1})$ and let $v_{1}$ be the incident vertex of $e_{1}$ farther to $r$; similarly, let $e_{2}$ be the edge of $T_{m}$ containing $q(u_{2})$ and let $v_{2}$ be the incident vertex of $e_{2}$ farther to $r$. Observe that $q(u_{1})$ is closer to $v_{ij}$ if and only if the lowest common ancestor of $v_{1}$ and $v_{2}$ is $v_{2}$, which can be determined in constant time by a lowest common ancestor query.

The above shows that we can compute $q(u)$ in constant time based on $q(u_{1})$ and $q(u_{2})$. Thus, we can compute $q(u)$ for all internal nodes $u$ of $\mathcal{T}$ in $O(n)$ time. The lemma thus follows. ∎

In addition to constructing the tree $\mathcal{T}$ as above, our preprocessing for $\mathcal{A}_{2}$ also includes building a lowest common ancestor query data structure on $T_{m}$ in $O(M)$ time, such that given any two vertices of $T_{m}$, we can compute their lowest common ancestor in $O(1)$ time [7, 21]. This finishes the preprocessing for $\mathcal{A}_{2}$. The total time is $O(M\log M+n\log^{2}M)$.

The following lemma gives our algorithm for performing operations on $\mathcal{T}$.

Lemma 14

Given any range $[k,j]$, we can answer each generalized candidate-center-query in $O(\log n)$ time, and each remove operation (i.e., deactivating an uncertain point) can be performed in $O(\log n)$ time.

Proof

We first describe how to perform the remove operations. Suppose an uncertain point $P_{i}$ is deactivated. Let $u_{i}$ be the leaf of $\mathcal{T}$ corresponding to the index $i$. We first set $q(u_{i})=\emptyset$. Then, we consider the path of $\mathcal{T}$ from $u_{i}$ to the root in a bottom-up manner, and for each node $u$, we update $q(u)$ based on $q(u_{1})$ and $q(u_{2})$ in constant time in exactly the same way as in Lemma 13, where $u_{1}$ and $u_{2}$ are the two children of $u$, respectively. In this way, each remove operation can be performed in $O(\log n)$ time.

Next we discuss the generalized candidate-center-query on a range $[k,j]$. By standard techniques, we can locate a set $S$ of $O(\log n)$ nodes of $\mathcal{T}$ such that the descendant leaves of these nodes exactly correspond to indices in the range $[k,j]$. We find the lowest common ancestor $v_{kj}$ of $p_{k}^{*}$ and $p_{j}^{*}$ in $T_{m}$ in constant time. Then, for each node $u\in S$, we check whether $q(u)$ is on $\pi(r,v_{kj})$, which can be done in constant time by using the lowest common ancestor query in the same way as in the proof of Lemma 13. If $q(u)$ is not on $\pi(r,v_{kj})$ for some $u\in S$, then we simply return $\emptyset$. Otherwise, $q(u)$ is on $\pi(r,v_{kj})$ for every $u\in S$. We further find the point $q(u)$ that is closest to $v_{kj}$ among all $u\in S$, and return it as the answer to the candidate-center-query on $[k,j]$. Such a $q(u)$ can be found by comparing the nodes of $S$ in $O(\log n)$ time. Specifically, for each pair $u$ and $u^{\prime}$ in a comparison, we find among $q(u)$ and $q(u^{\prime})$ the one closer to $v_{kj}$, which can be done in constant time by using the lowest common ancestor query in the same way as in the proof of Lemma 13, and then we keep comparing the above closer one to the rest of the nodes in $S$. In this way, the candidate-center-query can be handled in $O(\log n)$ time. ∎

This proves Lemma 5.

5.4 Handling the Degenerate Case and Reducing the General Case to the Vertex-Constrained Case

We have solved the vertex-constrained case problem, i.e., all locations of $\mathcal{P}$ are at vertices of $T$ and each vertex of $T$ contains at least one location of $\mathcal{P}$. Recall that we have made a general position assumption that every vertex of $T$ has only one location of $\mathcal{P}$. For the degenerate case, our algorithm still works in the same way as before with the following slight change. Consider a subtree $T(\mu)$ corresponding to a node $\mu$ of $\Upsilon$. In the degenerate case, since a vertex of $T(\mu)$ may hold multiple uncertain point locations of $\mathcal{P}$, we define the size $|T(\mu)|$ to be the total number of all uncertain point locations in $T(\mu)$. In this way, the algorithm and the analysis follow similarly as before. In fact, the performance of the algorithm becomes even better in the degenerate case since the height of the decomposition tree $\Upsilon$ becomes smaller (specifically, it is bounded by $O(\log t)$, where $t$ is the number of vertices of $T$, and $t<M$ in the degenerate case).

The above has solved the vertex-constrained case problem (including the degenerate case). In the general case, a location of $\mathcal{P}$ may be in the interior of an edge of $T$ and a vertex of $T$ may not hold any location of $\mathcal{P}$. The following theorem solves the general case by reducing it to the vertex-constrained case. The reduction is almost the same as the one given in [40] for the one-center problem and we include it here for the completeness of this paper.

Lemma 15

The center-coverage problem on $\mathcal{P}$ and $T$ is solvable in $O(\tau+M+|T|)$ time, where $\tau$ is the time for solving the same problem on $\mathcal{P}$ and $T$ if this were a vertex-constrained case.

Proof

We reduce the problem to an instance of the vertex-constrained case and then apply our algorithm for the vertex-constrained case. More specifically, we will modify the tree $T$ to obtain another tree $T^{\prime}$ of size $\Theta(M)$. We will also compute another set $\mathcal{P}^{\prime}$ of $n$ uncertain points on $T^{\prime}$, which correspond to the uncertain points of $\mathcal{P}$ with the same weights, but each uncertain point $P_{i}$ of $\mathcal{P}^{\prime}$ has at most $2m_{i}$ locations on $T^{\prime}$. Further, each location of $\mathcal{P}^{\prime}$ is at a vertex of $T^{\prime}$ and each vertex of $T^{\prime}$ holds at least one location of $\mathcal{P}^{\prime}$, i.e., it is the vertex-constrained case. We will show that we can obtain $T^{\prime}$ and $\mathcal{P}^{\prime}$ in $O(M+|T|)$ time. Finally, we will show that given a set of centers on $T^{\prime}$ for $\mathcal{P}^{\prime}$, we can find a corresponding set of the same number of centers on $T$ for $\mathcal{P}$ in $O(M+|T|)$ time. The details are given below.

We assume that for each edge $e$ of $T$, all locations of $\mathcal{P}$ on $e$ have been sorted (otherwise we sort them first, which would introduce an additional $O(M\log M)$ time on the problem reduction). We traverse $T$, and for each edge $e$, if $e$ contains some locations of $\mathcal{P}$ in its interior, we create a new vertex in $T$ for each such location. In this way, we create at most $M$ new vertices for $T$. The above can be done in $O(M+|T|)$ time. We use $T_{1}$ to denote the new tree. Note that $|T_{1}|=O(M+|T|)$. For each vertex $v$ of $T_{1}$, if $v$ does not hold any location of $\mathcal{P}$, we call $v$ an empty vertex.

Next, we modify $T_{1}$ in the following way. First, for each leaf $v$ of $T_{1}$, if $v$ is empty, then we remove $v$ from $T_{1}$. We keep doing this until each leaf of the remaining tree is not empty. Let $T_{2}$ denote the tree after the above step (e.g., see Fig. 6(b)). Second, for each internal vertex $v$ of $T_{2}$, if the degree of $v$ is $2$ and $v$ is empty, then we remove $v$ from $T_{2}$ and merge its two incident edges as a single edge whose length is equal to the sum of the lengths of the two incident edges of $v$. We keep doing this until each degree-2 vertex of the remaining tree is not empty. Let $T^{\prime}$ represent the remaining tree (e.g., see Fig. 6(c)). The above two steps can be implemented in $O(|T_{1}|)$ time, e.g., by a post-order traversal of $T_{1}$. We omit the details.

Notice that every location of $\mathcal{P}$ is at a vertex of $T^{\prime}$ and every vertex of $T^{\prime}$ except those whose degrees are at least three holds a location of $\mathcal{P}$. Let $V$ denote the set of all vertices of $T^{\prime}$ and let $V_{3}$ denote the set of the vertices of $T^{\prime}$ whose degrees are at least three. Clearly, $|V_{3}|\leq|V\setminus V_{3}|$. Since each vertex in $V\setminus V_{3}$ holds a location of $\mathcal{P}$, we have $|V\setminus V_{3}|\leq M$, and thus $|V_{3}|\leq M$.

To make every vertex of $T^{\prime}$ contain a location of an uncertain point, we first arbitrarily pick $m_{1}$ vertices from $V_{3}$ and remove them from $V_{3}$, and set a “dummy” location for $P_{1}$ at each of these vertices with zero probability. We keep picking next $m_{2}$ vertices from $V_{3}$ for $P_{2}$ and continue this procedure until $V_{3}$ becomes empty. Since $|V_{3}|\leq M$, the above procedure will eventually make $V_{3}$ empty before we “use up” all $n$ uncertain points of $\mathcal{P}$. We let $\mathcal{P}^{\prime}$ be the set of new uncertain points. For each $P_{i}\in\mathcal{P}$, it has at most $2m_{i}$ locations on $T^{\prime}$.

Since now every vertex of $T^{\prime}$ holds a location of $\mathcal{P}^{\prime}$ and every location of $\mathcal{P}^{\prime}$ is at a vertex of $T^{\prime}$, we obtain an instance of the vertex-constrained case on $T^{\prime}$ and $\mathcal{P}^{\prime}$. Hence, we can use our algorithm for the vertex-constrained case to compute a set $C^{\prime}$ of centers on $T^{\prime}$ in $O(\tau)$ time. In the following, for each center $c^{\prime}\in C^{\prime}$, we find a corresponding center $c$ on the original tree $T$ such that $P_{i}$ is covered by $c$ on $T$ if and only if $P^{\prime}_{i}$ is covered by $c^{\prime}$ on $T^{\prime}$.

Observe that every vertex $v$ of $T^{\prime}$ also exists as a vertex in $T_{1}$, and every edge $(u,v)$ of $T^{\prime}$ corresponds to the simple path in $T_{1}$ between $u$ and $v$. Suppose $c^{\prime}$ is on an edge $(u,v)$ of $T^{\prime}$ and let $\delta$ be the length of $e$ between $u$ and $c^{\prime}$. We locate a corresponding $c_{1}$ in $T_{1}$ in the simple path from $u$ to $v$ at distance $\delta$ from $u$. On the other hand, by our construction from $T$ to $T_{1}$, if an edge $e$ of $T$ does not appear in $T_{1}$, then $e$ is broken into several edges in $T_{1}$ whose total length is equal to that of $e$. Hence, every point of $T$ corresponds to a point on $T_{1}$. We find the point on $T$ that corresponds to $c_{1}$ of $T_{1}$, and let the point be $c$.

Let $C$ be the set of points $c$ on $T$ corresponding to all $c^{\prime}\in C^{\prime}$ on $T$, as defined above. Let $C_{1}$ be the set of points $c_{1}$ on $T_{1}$ corresponding to all $c^{\prime}\in C^{\prime}$ on $T^{\prime}$. To compute $C$, we first compute $C_{1}$. This can be done by traversing both $T^{\prime}$ and $T_{1}$, i.e., for each edge $e$ of $T^{\prime}$ that contains centers $c^{\prime}$ of $C^{\prime}$, we find the corresponding points $c_{1}$ in the path of $T_{1}$ corresponding to the edge $e$. Since the paths of $T_{1}$ corresponding to the edges of $T^{\prime}$ are pairwise edge-disjoint, the runtime for computing $C_{1}$ is $O(|T_{1}|+|T^{\prime}|)$. Next we compute $C$, and similarly this can be done by traversing both $T_{1}$ and $T$ in $O(|T_{1}|+|T|)$ time. Hence, the total time for computing $C$ is $O(|T|+M)$ since both $|T_{1}|$ and $|T^{\prime}|$ are bounded by $O(|T|+M)$.

As a summary, we can find an optimal solution for the center-coverage problem on $T$ and $\mathcal{P}$ in $O(\tau+M+|T|)$ time. The lemma thus follows. ∎

6 The $k$-Center Problem

The $k$-center problem is to find a set $C$ of $k$ centers on $T$ minimizing the value $\max_{1\leq i\leq n}d(C,P_{i})$, where $d(C,P_{i})=\min_{c\in C}d(c,P_{i})$. Let $\lambda_{opt}=\max_{1\leq i\leq n}d(C,P_{i})$ for an optimal solution $C$, and we call $\lambda_{opt}$ the optimal covering range.

As the center-coverage problem, we can also reduce the general $k$-center problem to the vertex-constrained case. The reduction is similar to the one in Lemma 15 and we omit the details. In the following, we only discuss the vertex-constrained case and we assume the problem on $T$ and $\mathcal{P}$ is a vertex-constrained case. Let $\tau$ denote the running time for solving the center-coverage algorithm on $T$ and $\mathcal{P}$.

To solve the $k$-center problem, the key is to compute $\lambda_{opt}$, after which we can compute $k$ centers in additional $O(\tau)$ time using our algorithm for the center-coverage problem with $\lambda=\lambda_{opt}$. To compute $\lambda_{opt}$, there are two main steps. In the first step, we find a set $S$ of $O(n^{2})$ candidate values such that $\lambda_{opt}$ must be in $S$. In the second step, we compute $\lambda_{opt}$ in $S$. Below we first compute the set $S$.

For any two medians $p_{i}^{*}$ and $p_{j}^{*}$ on $T_{m}$, observe that as $x$ moves on $\pi(p_{i}^{*},p_{j}^{*})$ from $p_{i}^{*}$ to $p_{j}^{*}$, $\mathsf{E}\mathrm{d}(x,P_{i})$ is monotonically increasing and $\mathsf{E}\mathrm{d}(x,P_{j})$ is monotonically decreasing (e.g., see Fig. 7); we define $c_{ij}$ to be a point on the path $\pi(p_{i}^{*},p_{j}^{*})$ with $\mathsf{E}\mathrm{d}(c_{ij},P_{i})=\mathsf{E}\mathrm{d}(c_{ij},P_{j})$, and we let $c_{ij}=\emptyset$ if such a point does not exist on $\pi(p_{i}^{*},p_{j}^{*})$. We have the following lemma.

Lemma 16

Either $\lambda_{opt}=\mathsf{E}\mathrm{d}(p_{i}^{*},P_{i})$ for some uncertain point $P_{i}$ or $\lambda_{opt}=\mathsf{E}\mathrm{d}(c_{ij},P_{i})=\mathsf{E}\mathrm{d}(c_{ij},P_{j})$ for two uncertain points $P_{i}$ and $P_{j}$.

Proof

Consider any optimal solution and let $C$ be the set of all centers. For each $c\in C$, let $Q(c)$ be the set of uncertain points that are covered by $c$ with respect to $\lambda_{opt}$, i.e., for each $P_{i}\in Q(c)$, $\mathsf{E}\mathrm{d}(c,P_{i})\leq\lambda_{opt}$. Let $C^{\prime}$ be the subset of all centers $c\in C$ such that $Q(c)$ has an uncertain point $P_{i}$ with $\mathsf{E}\mathrm{d}(c,P_{i})=\lambda_{opt}$ and there is no other center $c^{\prime}\in C$ with $\mathsf{E}\mathrm{d}(c^{\prime},P_{i})<\lambda_{opt}$. For each $c\in C^{\prime}$, let $Q^{\prime}(c)$ be the set of all uncertain points $P_{i}$ such that $\mathsf{E}\mathrm{d}(c,P_{i})=\lambda_{opt}$.

If there exists a center $c\in C^{\prime}$ with an uncertain point $P_{i}\in Q^{\prime}(c)$ such that $c$ is at $p_{i}^{*}$, then the lemma follows since $\lambda_{opt}=\mathsf{E}\mathrm{d}(c,P_{i})=\mathsf{E}\mathrm{d}(p_{i}^{*},P_{i})$. Otherwise, if there exists a center $c\in C^{\prime}$ with two uncertain points $P_{i}$ and $P_{j}$ in $Q^{\prime}(c)$ such that $c$ is at $c_{ij}$, then the lemma also follows since $\lambda_{opt}=\mathsf{E}\mathrm{d}(c_{ij},P_{i})=\mathsf{E}\mathrm{d}(c_{ij},P_{j})$. Otherwise, if we move each $c\in C^{\prime}$ towards the median $p_{j}^{*}$ for any $P_{j}\in Q^{\prime}(c)$, then $\mathsf{E}\mathrm{d}(c,P_{i})$ for every $P_{i}\in Q^{\prime}(c)$ becomes non-increasing. During the above movements of all $c\in C^{\prime}$, one of the following two cases must happen (since otherwise we would obtain another set $C^{\prime\prime}$ of $k$ centers with $\max_{1\leq i\leq n}d(C^{\prime\prime},P_{i})<\lambda_{opt}$, contradicting with that $\lambda_{opt}$ is the optimal covering range): either a center $c$ of $C^{\prime}$ arrives at a median $p_{i}^{*}$ with $\lambda_{opt}=\mathsf{E}\mathrm{d}(c,P_{i})=\mathsf{E}\mathrm{d}(p_{i}^{*},P_{i})$ or a center $c$ of $C^{\prime}$ arrives at $c_{ij}$ for two uncertain points $P_{i}$ and $P_{j}$ with $\lambda_{opt}=\mathsf{E}\mathrm{d}(c_{ij},P_{i})=\mathsf{E}\mathrm{d}(c_{ij},P_{j})$. In either case, the lemma follows. ∎

In light of Lemma 16, we let $S=S_{1}\cup S_{2}$ with $S_{1}=\{\mathsf{E}\mathrm{d}(p_{i}^{*},P_{i})\ |\ 1\leq i\leq n\}$ and $S_{2}=\{\mathsf{E}\mathrm{d}(c_{ij},P_{i})\ |\ 1\leq i,j\leq n\}$ (if $c_{ij}=\emptyset$ for a pair $i$ and $j$, then let $\mathsf{E}\mathrm{d}(c_{ij},P_{i})=0$). Hence, $\lambda_{opt}$ must be in $S$ and $|S|=O(n^{2})$.

We assume the data structure $\mathcal{A}_{3}$ has been computed in $O(M\log M)$ time. Then, computing the values of $S_{1}$ can be done in $O(n\log M)$ time by using $\mathcal{A}_{3}$. The following lemma computes $S_{2}$ in $O(M+n^{2}\log n\log M)$ time.

Lemma 17

After $O(M)$ time preprocessing, we can compute $\mathsf{E}\mathrm{d}(c_{ij},P_{i})$ in $O(\log n\cdot\log M)$ time for any pair $i$ and $j$.

Proof

As preprocessing, we do the following. First, we compute a lowest common ancestor query data structure on $T_{m}$ in $O(M)$ time such that given any two vertices of $T_{m}$, their lowest common ancestor can be found in $O(1)$ time [7, 21]. Second, for each vertex $v$ of $T_{m}$, we compute the length $d(v,r)$, i.e., the number of edges in the path of $T_{m}$ from $v$ to the root $r$ of $T_{m}$. Note that $d(v,r)$ is also the depth of $v$. Computing $d(v,r)$ for all vertices $v$ of $T_{m}$ can be done in $O(M)$ time by a depth-first-traversal of $T_{m}$ starting from $r$. For each vertex $v\in T_{m}$ and any integer $d\in[0,d(v,r)]$, we use $\alpha(v,d)$ to denote the ancestor of $v$ whose depth is $d$. We build a level ancestor query data structure on $T_{m}$ in $O(M)$ time that can compute $\alpha(v,d)$ in constant time for any vertex $v$ and any $d\in[0,d(v,r)]$ [8]. The total time of the above processing is $O(M)$.

Consider any pair $i$ and $j$. We present an algorithm to compute $c_{ij}$ in $O(\log n\cdot\log M)$ time, after which $\mathsf{E}\mathrm{d}(c_{ij},P_{i})$ can be computed in $O(\log M)$ time by using the data structure $\mathcal{A}_{3}$.

Observe that $c_{ij}\neq\emptyset$ if and only if $\mathsf{E}\mathrm{d}(p_{i}^{*},P_{i})\leq\mathsf{E}\mathrm{d}(p_{i}^{*},P_{j})$ and $\mathsf{E}\mathrm{d}(p_{j}^{*},P_{j})\leq\mathsf{E}\mathrm{d}(p_{j}^{*},P_{i})$. Using $\mathcal{A}_{3}$, we can compute the four expected distances in $O(\log M)$ time and thus determine whether $c_{ij}=\emptyset$. If yes, we simply return zero. Otherwise, we proceed as follows.

Note that $c_{ij}$ is a point $x\in\pi(p_{i}^{*},p_{j}^{*})$ minimizing the value $\max\{\mathsf{E}\mathrm{d}(x,P_{i}),\mathsf{E}\mathrm{d}(x,P_{j})\}$ (e.g., see Fig. 7). To compute $c_{ij}$, by using a lowest common ancestor query, we find the lowest common ancestor $v_{ij}$ of $p_{i}^{*}$ and $p_{j}^{*}$ in constant time. Then, we search $c_{ij}$ on the path $\pi(p_{i}^{*},v_{ij})$, as follows (we will search the path $\pi(p_{j}^{*},v_{ij})$ later). To simplify the notation, let $\pi=\pi(p_{i}^{*},v_{ij})$. By using the level ancestor queries, we can find the middle edge of $\pi$ in $O(1)$ time. Specifically, we find the two vertices $v_{1}=\alpha(p_{i}^{*},k)$ and $v_{2}=\alpha(p_{i}^{*},k+1)$, where $k=\lfloor(d(p_{i}^{*},r)+d(v_{ij},r))/2\rfloor$. Note that the two values $d(p_{i}^{*},r)$ and $d(v_{ij},r)$ are computed in the preprocessing. Hence, $v_{1}$ and $v_{2}$ can be found in constant time by the level ancestor queries. Clearly, the edge $e=(v_{1},v_{2})$ is the middle edge of $\pi$.

After $e$ is obtained, by using the data structure $\mathcal{A}_{3}$ and as remarked in Section 5.2, we can obtain the two functions $\mathsf{E}\mathrm{d}(x,P_{i})$ and $\mathsf{E}\mathrm{d}(x,P_{j})$ on $x\in e$ in $O(\log M)$ time, and both functions are linear in $x$ for $x\in e$. As $x$ moves in $e$ from one end to the other, one of $\mathsf{E}\mathrm{d}(x,P_{i})$ and $\mathsf{E}\mathrm{d}(x,P_{j})$ is monotonically increasing and the other is monotonically decreasing. Therefore, we can determine in constant time whether $c_{ij}$ is on $\pi_{1}$, $\pi_{2}$, or $e$, where $\pi_{1}$ and $\pi_{2}$ are the sub-paths of $\pi$ partitioned by $e$. If $c_{ij}$ is on $e$, then $c_{ij}$ can be computed immediately by the two functions and we can finish the algorithm. Otherwise, the binary search proceeds on either $\pi_{1}$ or $\pi_{2}$ recursively.

For the runtime, the binary search has $O(\log n)$ iterations and each iteration runs in $O(\log M)$ time. So the total time of the binary search on $\pi(p_{i}^{*},v_{ij})$ is $O(\log n\log M)$. The binary search will either find $c_{ij}$ or determine that $c_{ij}$ is at $v_{ij}$. The latter case actually implies that $c_{ij}$ is in the path $\pi(p_{j}^{*},v_{ij})$, and thus we apply the similar binary search on $\pi(p_{j}^{*},v_{ij})$, which will eventually compute $c_{ij}$. Thus, the total time for computing $c_{ij}$ is $O(\log n\log M)$.

The lemma thus follows. ∎

The following theorem summarizes our algorithm.

Theorem 6.1

An optimal solution for the $k$-center problem can be found in $O(n^{2}\log n\log M+M\log^{2}M\log n)$ time.

Proof

Assume the data structure $\mathcal{A}_{3}$ has been computed in $O(M\log M)$ time. Computing $S_{1}$ can be done in $O(n\log M)$ time. Computing $S_{2}$ takes $O(M+n^{2}\log n\log M)$ time. After $S$ is computed, we find $\lambda_{opt}$ from $S$ as follows.

Given any $\lambda$ in $S$, we can use our algorithm for the center-coverage problem to find a minimum number $k^{\prime}$ of centers with respect to $\lambda$. If $k^{\prime}\leq k$, then we say that $\lambda$ is feasible. Clearly, $\lambda_{opt}$ is the smallest feasible value in $S$. To find $\lambda_{opt}$ from $S$, we first sort all values in $S$ and then do binary search using our center-coverage algorithm as a decision procedure. In this way, $\lambda_{opt}$ can be found in $O(n^{2}\log n+\tau\log n)$ time.

Finally, we can find an optimal solution using our algorithm for the covering problem with $\lambda=\lambda_{opt}$ in $O(\tau)$ time. Therefore, the total time of the algorithm is $O(n^{2}\log n\log M+\tau\log n)$, which is $O(n^{2}\log n\log M+M\log^{2}M\log n)$ by Theorem 3.1. ∎