Dynamic Planar Point Location in External Memory

TL;DR

This paper introduces a fully-dynamic external memory data structure for planar point location that achieves near-optimal query and update I/O performance, significantly improving upon previous methods.

Contribution

It presents the first dynamic data structure for planar point location in external memory with near-optimal query costs, matching internal-memory bounds.

Findings

Supports queries in O(log_B n (log log_B n)^3) I/Os

Supports updates in O(log_B n (log log_B n)^2) amortized I/Os

First dynamic external memory structure with almost-optimal query performance

Abstract

In this paper we describe a fully-dynamic data structure for the planar point location problem in the external memory model. Our data structure supports queries in $O(\log_B n(\log\log_B n)^3))$ I/Os and updates in $O(\log_B n(\log\log_B n)^2))$ amortized I/Os, where $n$ is the number of segments in the subdivision and $B$ is the block size. This is the first dynamic data structure with almost-optimal query cost. For comparison all previously known results for this problem require $O(\log_B^2 n)$ I/Os to answer queries. Our result almost matches the best known upper bound in the internal-memory model.

Figures

Tables

Table 1. Table 1 : Previous results on dynamic planar point location in internal memory. Entries marked † and ‡ require amortization and (Las Vegas) randomization respectively, ε > 0 𝜀 0 \varepsilon>0 is an arbitrarily small constant. Results marked ∗ are in the RAM model, all other results are in the pointer machine model. Space usage is measured in words.

Reference	Space	Query Time	Insertion Time	Deletion Time
Bentley [11]	$n\log n$	${\log }^{2}n$	${\log }^{2}n$	${\log }^{2}n$
Cheng–Janardan [16]	$n$	${\log }^{2}n$	$\log n$	$\log n$
Baumgarten et al. [9]	$n$	$\log n\log \log n$	$\log n\log \log n$	${\log }^{2}n$	†
Arge et al. [3]	$n$	$\log n$	${\log }^{1+\epsilon }n$	${\log }^{2+\epsilon }n$	†
Arge et al. [3]	$n$	$\log n$	$\log n{\left(\log \log n\right)}^{1+\epsilon }$​	${\log }^{2}n/\log \log n$​	†‡∗​
Chan and Nekrich [13]	$n$	$\log n{\left(\log \log n\right)}^2$​	$\log n\log \log n$	$\log n\log \log n$
Chan and Nekrich [13]	$n$	$\log n$	${\log }^{1+\epsilon }n$	${\log }^{1+\epsilon }n$
Chan and Nekrich [13]	$n$	$\log n$	${\log }^{1+\epsilon }n$	$\log n{\left(\log \log n\right)}^{1+\epsilon }$​	∗
Chan and Nekrich [13]	$n$	${\log }^{1+\epsilon }n$	$\log n$	$\log n$
Chan and Nekrich [13]	$n$	$\log n\log \log n$​	$\log n\log \log n$	$\log n\log \log n$	${}^{‡\ast }$

Table 2. Table 2 : Previous and new results on dynamic planar point location in external memory. G denotes most general subdivisions, M denotes monotone subdivision, and O denotes orthogonal subdivision. Space usage is measured in words and update cost is amortized.

Reference	Space	Query Cost	Insertion Cost	Deletion Cost
Agarwal et al [1]	$n$	${\log }_B^{2}n$	${\log }_B^{2}n$	${\log }_B^{2}n$	M
Arge and Vahrenhold [7]	$n$	${\log }_B^{2}n$	${\log }_B^{2}n$	${\log }_{B}n$	G
Arge et al [4]	$n$	${\log }_B^{2}n$	${\log }_{B}n$	${\log }_{B}n$	G
This paper	$n$	${\log }_{B}n{\left(\log {\log }_{B}n\right)}^3$	${\log }_{B}n{\left(\log {\log }_{B}n\right)}^2$	${\log }_{B}n{\left(\log {\log }_{B}n\right)}^2$	G
This paper	$n$	${\log }_{B}n\log {\log }_{B}n$	${\log }_{B}n\log {\log }_{B}n$	${\log }_{B}n\log {\log }_{B}n$	O

Equations

$$\sum _{i=0}^h{\log }_B(W_i/{\omega }_i)={\log }_B{W}_0+\sum _{i=0}^{h-1}({\log }_B{W}_{i+1}-{\log }_B{\omega }_i)-{\log }_B{\omega }_h\le {\log }_B(W_0/{\omega }_h)+2(h+1){\log }_{B}r.$$

$$weigh{t}_i(e,u)=W(e_1,e_2,u_i)/d.$$

$$\sum _{i=0}^h\log (W_i/{\omega }_i)=\log W_0+\sum _{i=0}^{h-1}(\log W_{i+1}-\log {\omega }_i)-\log {\omega }_h\le \log (W_0/{\omega }_h)+2(h+1)\log r.$$

Full text

1 Introduction

Planar point location is a classical computational geometry problem with a number of important applications. In this problem we keep a polygonal subdivision $\Pi$ of the two-dimensional plane in a data structure; for an arbitrary query point $q$, we must be able to find the face of $\Pi$ that contains $q$. In this paper we study the dynamic version of this problem in the external memory model. We show that a planar subdivision can be maintained under insertions and deletions of edges, so that the cost of queries and updates is close to $O(\log_{B}n)$, where $n$ is the number of segments in the subdivision and $B$ is the block size.

Planar point location problem was studied extensively in different computational models. Dynamic internal-memory data structures for general subdivisions were described by Bentley [11], Cheng and Janardan [16], Baumgarten et al. [9], Arge et al. [3], and Chan and Nekrich [13]. Table 1 lists previous results. We did not include in this table many other results for special cases of the point location problem, such as the data structures for monotone, convex, and orthogonal subdivisions, e.g., [26, 27, 18, 17, 21, 20, 14]. The currently best data structure [13] achieves111In this paper $\log n$ denotes the binary logarithm of $n$ when the logarithm base is not specified. $O(\log n)$ query time and $O(\log^{1+\varepsilon}n)$ update time or $O(\log^{1+\varepsilon}n)$ query time and $O(\log n)$ update time; the best query-update trade-off described in [13] is $O(\log n\log\log n)$ randomized query time and $O(\log n\log\log n)$ update time. See Table 1.

In the external memory model [2] the data can be stored in the internal memory of size $M$ or on the external disk. Arithmetic operations can be performed only on data in the internal memory. Every input/output operation (I/O) either reads a block of $B$ contiguous words from the disk into the internal memory or writes $B$ words from the internal memory into disk. Measures of efficiency in this model are the number of I/Os needed to solve a problem and the amount of used disk space.

Goodrich et al. [22] presented a linear-space static external data structure for point location in a monotone subdivision with $O(\log_{B}n)$ query cost. Arge et al. [5] designed a data structure for a general subdivison with the same query cost. Data structures for answering a batch of point location queries were considered in [22] and [8]. Only three external-memory results are known for the dynamic case. The data structure of Agarwal, Arge, Brodal, and Vitter [1] supports queries on monotone subdivisions in $O(\log_{B}^{2}n)$ I/Os and updates in $O(\log^{2}_{B}n)$ I/Os amortized. Arge and Vahrenhold [7] considered the case of general subdivisons; they retain the same cost for queries and insertions as [1] and reduce the deletion cost to $O(\log_{B}n)$. Arge, Brodal, and Rao [4] reduced the insertion cost to $O(\log_{B}n)$. Thus all previous dynamic data structures did not break $O(\log^{2}_{B}n)$ query cost barrier. For comparison the first internal-memory data structure with query time close to logarithmic was presented by Baumgarten et al [9] in 1994. See Table 2. All previous data structures use $O(n)$ words of space (or $O(n/B)$ blocks of $B$ words222Space usage of external-memory data structures is frequently measured in disk blocks of $B$ words. In this paper we measure the space usage in words. But the space usage of $O(n)$ words is equivalent to $O(n/B)$ blocks of space.).

In this paper we show that it is possible to break the $O(\log^{2}_{B}n)$ barrier for the dynamic point location problem. Our data structure answers queries in $O(\log_{B}n(\log\log_{B}n)^{3})$ I/Os, supports updates in $O(\log_{B}n(\log\log_{B}n)^{2})$ I/Os amortized, and uses linear space. Thus we achieve close to logarithmic query cost and a query-update trade-off almost matching the state-of-the-art upper bounds in the internal memory model. Our result is within double-logarithmic factors from optimal. Additionally we describe a data structure that supports point location queries in an orthogonal subdivision with $O(\log_{B}n\log\log_{B}n)$ query cost and $O(\log_{B}n\log\log_{B}n)$ amortized update cost. The computational model used in this paper is the standard external memory model [2].

2 Overview

2.1 Overall Structure

As in the previous works, we concentrate on answering vertical ray shooting queries. The successor segment of a point $q$ in a set $S$ of non-intersecting segments is the first segment that is hit by a ray emanating from $q$ in the $+y$-direction. Symmetrically, the predecessor segment of $q$ in $S$ is the first segment hit by a ray emanating from $q$ in the $-y$ direction. A vertical ray shooting query for a point $q$ on a set of segments $S$ asks for the successor segment of $q$ in $S$. If we know the successor segment or the predecessor segment of $q$ among all segments of a subdivision $\Pi$, then we can answer a point location query on $\Pi$ (i.e., identify the face of $\Pi$ containing $q$) in $O(\log_{B}n)$ I/Os [7]. In the rest of this paper we will show how to answer vertical ray shooting queries on a dynamic set of non-intersecting segments.

Our base data structure is a variant of the segment tree. Let ${\cal S}$ be a set of segments. We store a tree ${\cal T}$ on $x$-coordinates of segment endpoints. Every leaf contains $\Theta(B)$ segment endpoints and every internal node has $r=\Theta(B^{\delta})$ children for $\delta=1/8$. Thus the height of ${\cal T}$ is $O(\log_{B}n)$. We associate a vertical slab with every node $u$ of ${\cal T}$. The slab of the root node is $[x_{\min},x_{\max}]\times\mathbb{R}$, where $x_{\min}$ and $x_{\max}$ denote the $x$-coordinates of the leftmost and the rightmost segment endpoints. The slab of an internal node $u$ is divided into $\Theta(B^{\delta})$ slabs that correspond to the children of $u$. A segment $s$ spans the slab of a node $u$ (or simply spans $u$) if it crosses its vertical boundaries.

A segment $s$ is assigned to an internal node $u$, if $s$ spans at least one child $u_{i}$ of $u$ but does not span $u$. We assign $s$ to a leaf node $\ell$ if at least one endpoint of $s$ is stored in $\ell$. All segments assigned to a node $u$ are trimmed to slab boundaries of children and stored in a multi-slab data structure $C(u)$: Suppose that a segment $s$ is assigned to $u$ and it spans the children $u_{f}$, $\ldots$, $u_{l}$ of $u$. Then we store the segment $s_{u}=[p_{f},p_{l}]$ in $C(u)$, where $p_{f}$ is the point where $s$ intersect the left slab boundary of $u_{f}$ and $p_{l}$ is the point where $s$ intersects the right boundary of $u_{l}$. See Fig. 1. Each segment is assigned to $O(\log_{B}n)$ nodes of ${\cal T}$.

In order to answer a vertical ray shooting query for a point $q$, we identify the leaf $\ell$ such that the slab of $\ell$ contains $q$. Then we visit all nodes $u$ on the path $\pi_{\ell}$ from the root of ${\cal T}$ to $\ell$ and answer vertical ray shooting queries in multi-slab structures $C(u)$.

2.2 Our Approach

Thus our goal is to answer $O(\log_{B}n)$ ray shooting queries in multi-slab structures along a path in the segment tree ${\cal T}$ with as few I/Os as possible. Segments stored in a multi-slab are not comparable in the general case; see Fig. 2. It is possible to impose a total order $\prec$ on all segments in the following sense: let $l$ be a vertical line that intersects segments $s_{1}$ and $s_{2}$; if the intersection of $l$ with $s_{1}$ is above the intersection of $l$ with $s_{2}$, then $s_{2}\prec s_{1}$. We can find such a total order in $O((K/B)\log_{M/B}K)$ I/Os, where $K$ is the number of segments [8, Lemma 3]. But this ordering is not stable under updates: even a single deletion and a single insertion can lead to significant changes in the order of segments. See Fig. 2. Therefore it is hard to apply standard techniques, such as fractional cascading [15, 25], in order to speed-up ray shooting queries. Previous external-memory solutions in [1, 4] essentially perform $O(\log_{B}n)$ independent searches in the nodes of a segment tree or an interval tree in order to answer a query. Each search takes $O(\log_{B}n)$ I/Os, hence the total query cost is $O(\log_{B}^{2}n)$.

Internal memory data structures achieve $O(\log n)$ query cost using dynamic fractional cascading [15, 25]. Essentially the difference with external memory is as follows: since we aim for $O(\log_{2}n)$ query cost in internal memory, we can afford to use base tree ${\cal T}$ with small node degree. In this special case the segments stored in sets $C(u)$, $u\in{\cal T}$, can be ordered resp. divided into a small number of ordered sets. When the order of segments in $C(u)$ is known, we can apply the fractional cascading technique [15, 25] to speed up queries. Unfortunately dynamic fractional cascading does not work in the case when the total order of segments in $C(u)$ is not known. Hence we cannot use previous internal memory solutions of the point location problem  [16, 9, 3, 13] to decrease the query cost in external memory.

In this paper we propose a different approach. Searching in a multi-slab structure $C(u)$ is based on a weighted search among segments of $C(u)$. Weights of segments are chosen in such way that the total cost of searching in all multi-slab structures along a path $\pi$ is logarithmic. We also use fractional cascading, but this technique plays an auxiliary role: we apply fractional cascading to compute the weights of segments and to navigate between the tree nodes. Interestingly, fractional cascading is usually combined with the union-split-find data structure, which is not used in our construction.

This paper is structured as follows. In Section 3 we show how our new technique, that will be henceforth called weighted telescoping search, can be used to solve the static vertical ray shooting problem. Next we turn to the dynamic case. In our exposition we assume, for simplicity, that the set of segment $x$-coordinates is fixed, i.e., the tree ${\cal T}$ does not change. We also assume that the block size $B$ is sufficiently large, $B>\log^{8}n$. We show how our static data structure from Section 3 can be modified to support insertions in Section 4. To maintain the order of segments in a multi-slab under insertions we pursue the following strategy: when a new segment is inserted into the multi-slab structure $C(u)$, we split it into a number of unit segments, such that every unit segment spans exactly one child of $u$. Unit segments can be inserted into a multi-slab so that the order of other segments is not affected. The number of unit segments per inserted segment can be large; however we can use buffering to reduce the cost of updates.333As a side remark, this approach works with weighted telescoping search, but it would not work with the standard fractional cascading used in internal-memory solutions [16, 9, 3, 13]. The latter technique relies on a union-split-find data structure (USF) and it is not known how to combine buffering with USF. We need to make some further changes in our data structure in order to support deletions; the fully-dynamic solution for large $B$ is described in Section 5. The main result of Section 5, summed up in Lemma 2, is the data structure that answers queries in $O(\log_{B}n\log\log_{B}n)$ I/Os; insertions and deletions are supported in $O(\log^{2}_{B}n)$ and $O(\log_{B}n)$ amortized I/Os respectively. We show how to reduce the cost of insertions and the space usage in Sections 6 and Appendix A respectively. We address some missing technical details and consider the case of small block size $B$ in Section 7. The special case of vertical ray shooting among horizontal segments is studied in Appendix B. Appendix C provides an alternative introduction to the weighted telescoping search by explaining how this technique works in a simplified scenario. This section is not used in the rest of the paper; the sole purpose of Appendix C is to provide an additional explanation for the weighted telescoping search.

3 Ray Shooting: Static Structure

In this section we show how the weighted telescoping search can be used to solve the static point location problem. Let ${\cal T}$ be the tree, defined in Section 2.1, with node degree $r=B^{\delta}$ for $\delta=1/8$. Let $C(u)$ be the set of segments that span at least one child of $u$ but do not span $u$.

Augmented Catalogs. We keep augmented catalogs $AC(u)\supset C(u)$ in every node $u$. Each $AC(u)$ is divided into subsets $AC_{ij}(u)$ for $1\leq i\leq j\leq r$; $AC_{ij}(u)$ contains segments that span children $u_{i}$, $\ldots$, $u_{j}$ of $u$ and only those children. Augmented catalogs $AC(u)$ satisfy the following properties:

• (i)

If a segment $s\in(AC(u)\setminus C(u))$, then $s\in C(v)$ for an ancestor $v$ of $u$ and $s$ spans $u$.

• (ii)

Let $E_{i}(u)=AC(u)\cap AC(u_{i})$ for a child $u_{i}$ of $u$. For any $f$ and $l$, $f\leq i\leq l$, there are at most $d=O(r^{4})$ elements of $AC_{fl}(u)$ between any two consecutive elements of $E_{i}(u)$.

• (iii)

If $i\not=j$, then $E_{i}(u)\cap E_{j}(u)=\emptyset$.

Elements of $E_{i}(u)$ for some $1\leq i\leq r$ will be called down-bridges; elements of the set $UP(u)=AC(u)\cap AC(\mathit{par}(u))$, where $\mathit{par}(u)$ denotes the parent node of $u$, are called up-bridges. We will say that a sub-list of a catalog $AC(u)$ bounded by two up-bridges is a portion of $AC(u)$. We refer to e.g., [3] or [13] for an explanation how we can construct and maintain $AC(u)$. We assume in this section that all segments in every catalog $AC(u)$ are ordered. We can easily order a set $AC_{fl}(u)$ or any set of segments that cross the same vertical line $\ell$: the order of segments is determined by ($y$-coordinates of) intersection points of segments and $\ell$. Therefore we will speak of e.g., the largest/smallest segments in such a set.

Element weights. We assign the weight to each element of $AC(u)$ in a bottom-to-top manner: All segments in a set $AC(\ell)$ for every leaf node $\ell$ are assigned weight $1$. Consider a segment $s\in AC_{fl}(u)$, i.e., a segment that spans children $u_{f}$, $\ldots$, $u_{l}$ of some internal node $u$. For $f\leq i\leq l$ let $s_{1}$ denote the largest bridge in $E_{i}(u)$ that is (strictly) smaller than $s$ and let $s_{2}$ denote the smallest bridge in $E_{i}(u)$ that is (strictly) larger than $s$; we let $W(s_{1},s_{2},u_{i})=\sum_{s_{1}<s^{\prime}<s_{2}}weight(s^{\prime},u_{i})$, where the sum is over all segments $s^{\prime}\in AC(u_{i})$ and $weight_{i}(s,u)=W(s_{1},s_{2},u_{i})/d$. See Fig. 3 for an example. We set $weight(s,u)=\sum_{i=f}^{l}weight_{i}(s,u)$. We keep a weighted search tree for every portion ${\cal P}(u)$ of the list $AC(u)$ By a slight misuse of notation this tree will also be denoted by ${\cal P}(u)$. Thus every catalog $AC(u)$ is stored in a forest of weighted trees ${\cal P}_{j}(u)$ where every tree corresponds to a portion of $AC(u)$ 444In most cases we will omit the subindex and will speak of a weighted tree ${\cal P}(u)$ because it will be clear from the context what portion of $AC(u)$ is used.. We also store a data structure supporting finger searches on $AC(u)$.

Weighted Trees. Each weighted search tree is implemented as a biased $(a,b)$-tree with parameters $a=B^{\delta}/2$ and $b=B^{\delta}$ [10, 19]. The depth of a leaf $\lambda$ in a biased $(B^{\delta}/2,B^{\delta})$-tree is bounded by $O(\log_{B}(W/w_{\lambda}))$, where $w_{\lambda}$ is the weight of an element in the leaf $\lambda$ and $W$ is the total weight of all elements in the tree. Every internal node $\nu$ has $B^{\delta}$ children and every leaf holds $\Theta(B)$ segments555In the standard biased ($a,b$)-tree [10, 19], every leaf holds one element. But we can modify it so that every leaf holds $\Theta(B)$ different elements (segments). The weight of a leaf $\lambda$ is the total weight of all segments stored in $\lambda$.. In each internal node $\nu$ we keep $B^{3\delta}$ segments $\nu.\max_{jk}[i]$. For every child $\nu_{i}$ of $\nu$ and for all $j$ and $k$, $1\leq j\leq k\leq r$, $\nu.\max_{jk}[i]$ is the highest segment from $AC_{jk}$ in the subtree of $\nu_{i}$ ; if there are no segments from $AC_{jk}$ in the subtree of $\nu_{i}$, then $\nu.\max_{jk}[i]=\mathrm{NULL}$. Using values of $\nu.\max$ we can find, for any node $\nu$ of the biased search tree, the child $\nu_{i}$ of $\nu$ that holds the successor segment of the query point $q$. Hence we can find the smallest segment $n(u)$ in a portion ${\cal P}(u)$ that is above a query point $q$ in $O(\log_{B}(W_{P}/\omega_{n}))$ I/Os where $W_{P}$ is the total weight of all segments in ${\cal P}(u)$ and $\omega_{n}$ is the weight of $n(u)$.

Additional Structures. When the segment $n(u)$ is known, we will need to find the bridges that are closest to $n(u)$ in order to continue the search. We keep a list $V_{i}(u)\subseteq AC(u)$ for each node $u$ and for every $i$, $1\leq i\leq r$. $V_{i}(u)$ contains all segments of $E_{i}(u)$ and some additional segments chosen as follows: $AC(u)$ is divided into groups so that each group consists of $\Theta(r^{6})$ consecutive segments; the only exception is the last group in $AC(u)$ that contains $O(r^{6})$ segments (here we use the fact that segments in $AC(u)$ are ordered). We choose the constant in such way that every group but the last one contains $d\cdot r^{2}$ segments. If a group $G$ contains a segment that spans $u_{i}$, then we select the highest segment from $G$ that spans $u_{i}$ and the lowest segment from $G$ that spans $u_{i}$; we store both segments in $V_{i}$. See Fig. 4. For every segment in $V_{i}$ we also store a pointer to its group in $AC(u)$. We keep $V_{i}$ in a B-tree that supports finger search queries.

Suppose that we know the successor segment $n(u)$ of a query point $q$ in $AC(u)$. We can find the successor segment $b_{n}(u)$ of $q$ in $E_{i}(u)$ using $V_{i}$: Let $G$ denote the group that contains $n(u)$. We search in $G$ for the segment $b_{n}(u)\geq n(u)$ using finger search. If $b_{n}(u)$ is not in $G$, we consider the highest segment $s_{1}\in G$ that spans $u_{i}$. By definition of $AC(u)$, there are at most $dr^{2}$ segments between $n(u)$ and $b_{n}(u)$. We can find $b_{n}(u)$ in $O(\log_{B}(dr^{2}))=O(1)$ I/Os by finger search on $V_{i}$ using $s_{1}$ as the finger. Using a similar procedure, we can find the highest bridge segment $b_{p}(u)\leq n(u)$ in $E_{i}(u)$.

Queries. A vertical ray shooting query for a point $q=(q_{x},q_{y})$ is answered as follows. Let $\ell$ denote the leaf such that the slab of $\ell$ contains $q$. We visit all nodes $v_{0}$, $v_{1}$, $\ldots$, $v_{h}$ on the root-to-leaf path $\pi(\ell)$ where $v_{0}$ is the root node and $v_{h}=\ell$. We find the segment $n(v_{i})$ in every visited node, where $n(v_{i})$ is the successor segment of $q$ in $AC(v_{i})$. Suppose that $v_{i+1}$ is the $j$-th child of $v_{i}$; $n(v_{i})$ spans the $j$-th child of $v_{i}$. First we search for $n(v_{0})$ in the weighted tree of $AC(v_{0})$. Next, using the list $V_{j}$, we identify the smallest bridge $b_{n}(v_{0})\in E_{j}(v_{0})$ such that $b_{n}(v_{0})\geq n(v_{0})$ and the largest bridge segment $b_{p}(v_{0})\in E_{j}(v_{0})$ such that $b_{p}(v_{0})\leq n(v_{0})$. The index $j$ is chosen so that $v_{1}$ is the $j$-th child of $v_{0}$. We execute the same operations in nodes $v_{1}$, $\ldots$, $v_{h}$. When we are in a node $v_{i}$ we consider the portion ${\cal P}(v_{i})$ between bridges $b_{p}(v_{i-1})$ and $b_{n}(v_{i-1})$; we search in the weighted tree of ${\cal P}(v_{i})$ for the successor segment $n(v_{i})$ of $q$. Then we identify the lowest bridge $b_{n}(v_{i})\geq n(v_{i})$ and the highest bridge $b_{p}(v_{i})\leq n(v_{i})$. When all $n(v_{i})$ are computed, we find the lowest segment $n^{*}$ among $n(v_{i})$. Since $\cup_{i=0}^{h}AC(v_{i})=\cup_{i=0}^{h}C(v_{i})$, $n^{*}$ is the successor segment of a query point $q$.

The cost of a ray shooting query can be estimated as follows. Let $\omega_{i}$ denote the weight of $n(v_{i})$. Let $W_{i}$ denote the total weight of all segments of ${\cal P}(v_{i})$ (we assume that ${\cal P}(v_{0})=AC(v_{0})$). Search for $n(v_{i})$ in the weighted tree ${\cal P}(v_{i})$ takes $O(\log_{B}(W_{i}/\omega_{i}))$ I/Os. By definition of weights, $\omega_{i}\geq W_{i+1}/d$. Hence

[TABLE]

We have $\omega_{h}=1$ and we will show below that $W_{0}\leq n$. Since $r=B^{\delta}$, $h=O(\log_{B}n)$ and $\log_{B}r=O(1)$. Hence the sum above can be bounded by $O(\log_{B}n)$. When $n(v_{i})$ is known, we can find $b_{p}(v_{i})$ and $b_{n}(v_{i})$ in $O(1)$ I/Os, as described above. Hence the total cost of answering a query is $O(\log_{B}n)$. Since every segment is stored in $O(\log_{B}n)$ lists $AC(u)$, the total space usage is $O(n\log_{B}n)$.

It remains to prove that $W_{0}\leq n$. We will show by induction that the total weight of all elements on every level of ${\cal T}$ is bounded by $n$: Every element in a leaf node has weight $1$; hence their total weight does not exceed $n$. Suppose that, for some $k\geq 1$, the total weight of all elements on level $k-1$ does not exceed $n$. Consider an arbitrary node $v$ on level $k$, let $v_{1}$, $\ldots$, $v_{r}$ be the children of $v$, and let $m_{i}$ denote the total weight of elements in $AC(v_{i})$. Every element in $AC(v_{i})$ contributes $1/d$ fraction of its weight to at most $d$ different elements in $AC(v)$. Hence $\sum_{e\in AL(v)}weight_{i}(v)\leq m_{i}$ and the total weight of all elements in $AC(v)$ does not exceed $\sum_{i=1}^{r}m_{i}$. Hence, for any level $k\geq 1$, the total weight of $AC(v)$ for all nodes $v$ on level $k$ does not exceed $n$. Hence the total weight of $AC(u_{0})$ for the root node $u_{0}$ is also bounded by $n$.

Lemma 1

There exists an $O(n\log_{B}n)$-space static data structure that supports point location queries on $n$ non-intersecting segments in $O(\log_{B}n)$ I/Os.

The result of Lemma 1 is not new. However we will show below that the data structure described in this section can be dynamized.

4 Semi-Dynamic Ray Shooting for $B\geq\log^{8}n$: Main Idea

Now we turn to the dynamic problem. In Sections 4 and 5 we will assume666Probably a smaller power of $\log$ can be used, but we consider $B\geq\log^{8}n$ to simplify the analysis. that $B\geq\log^{8}n$. Overview. The main challenge in dynamizing the static data structure from Section 3 is the order of segments. Deletions and insertions of segments can lead to significant changes in the segment order, as explained in Section 2. However segment insertions within a slab are easy to handle in one special case. We will say that a segment $s\in AC(u)$ is a unit segment if $s\in AC_{ii}(u)$ for some $1\leq i\leq r$. In other words a unit segment spans exactly one child $u_{i}$ of $u$. Let $L_{i}(u)=\cup_{f\leq i\leq l}AC_{fl}(u)$ denote the conceptual list of all segments that span $u_{i}$. When a unit segment $s\in AC_{ii}(u)$ is inserted, we find the segments $s_{p}$ and $s_{n}$ that precede and follow $s$ in $L_{i}(u)$; we insert $s$ at an arbitrary position in $AC(u)$ so that $s_{p}<s<s_{n}$. It is easy to see that the correct order of segments is maintained: the correct order is maintained for the segments that span $u_{i}$ and other segments are not affected.

An arbitrary segment $s$ that is to be inserted into $AC(u)$ can be represented as $B^{\delta}$ unit segments. See Fig. 5 for an example. However we cannot afford to spend $B^{\delta}$ operations for an insertion. To solve this problem, we use bufferization: when a segment is inserted, we split it into $B^{\delta}$ unit segments and insert them into a buffer ${\cal B}$. A complete description of the update procedure is given below.

Buffered Insertions. We distinguish between two categories of segments, old segments and new segments. We know the total order in the set of old segments in the portion ${\cal P}(u)$ (and in the list $AC(u)$). New segments are represented as a union of up to $r$ unit segments. When the number of new segments in a portion ${\cal P}(u)$ exceeds the threshold that will be specified below, we re-build ${\cal P}(u)$: we compute the order of old and new segments and declare all segments in ${\cal P}(u)$ to be old.

As explained in Section 3 every portion ${\cal P}(u)$ of $AC(u)$ is stored in a biased search tree data structure. Each node of ${\cal P}(u)$ has a buffer ${\cal B}(\nu)$ that can store up to $B^{3\delta}$ segments. When a new segment is inserted into ${\cal P}(u)$, we split it into unit segments and add them to the insertion buffer of $\nu_{r}$, where $\nu_{r}$ is the root node of ${\cal P}(u)$. When the buffer of an internal node $\nu$ is full, we flush it, i.e., we move all segments from ${\cal B}(\nu)$ to buffers in the children of $\nu$. We keep values $\nu.\max_{kj}[i]$, defined in Section 3, for all internal nodes $\nu$. All $\nu.\max_{kl}[\cdot]$ and all segments in ${\cal B}(\nu)$ fit into one block of memory; hence we can flush the buffer of an internal node in $O(B^{\delta})$ I/Os. When the buffer of an internal node is flushed, we do not change the shape of the tree. When the buffer ${\cal B}(\lambda)$ of a leaf node $\lambda$ is full, we insert segments from ${\cal B}(\lambda)$ into the set of segments stored in $\lambda$. If necessary we create a new leaf $\lambda^{\prime}$ and update the weights of $\lambda$ and $\lambda^{\prime}$. We can update the biased search tree ${\cal P}(u)$ in $O(\log n)$ time. We also update data structures $V_{i}$ for $i=1$, $\ldots$, $r$. Since a leaf node contains the segments from at most two different groups, we can update all $V_{i}$ in $O(r)$ I/Os. The biased tree is updated in $O(\log n)$ I/Os. The total amortized cost of a segment insertion into a portion ${\cal P}(u)$ is $O(1+\frac{\log n+r}{B^{3\delta}}+\frac{\log_{B}n}{B^{2\delta}})=O(1)$ because $B^{\delta}>\log n$.

When the number of new segments in ${\cal P}(u)$ is equal to $n_{\mathtt{old}}/r$, where $n_{\mathtt{old}}$ is the number of old segments in ${\cal P}(u)$, we rebuild ${\cal P}(u)$. Using the method from [8], we order all segments in ${\cal P}(u)$ and update the biased tree. Sorting of segments takes $O((n_{\mathtt{old}}/B)\log_{M/B}n_{\mathtt{old}})=o(n_{\mathtt{old}})$ I/Os. We can re-build the weighted tree ${\cal P}(u)$ in $O((n_{\mathtt{old}}/B^{3\delta})\log n_{\mathtt{old}})=o(n_{\mathtt{old}})$ I/Os by computing the weights of leaves and inserting the leaves into the new tree one-by-one.

When a new segment $s$ is inserted, we identify all nodes $u_{i}$ where $s$ must be stored. For every corresponding list $AC(u_{i})$, we find the portion ${\cal P}(u_{i})$ where $s$ must be stored. This takes $O(\log_{B}^{2}n)$ I/Os in total. Then we insert the trimmed segment $s$ into each portion as described above. The total insertion cost is $O(\log_{B}^{2}n)$. Queries are supported in the same way as in the static data structure described in Section 3. The only difference is that biased tree nodes have associated buffers. Many technical aspects are not addressed in this section. We fill in the missing details and provide the description of the data structure that also supports deletions in Section 5.

5 Ray Shooting for $B\geq\log^{8}n$: Fully-Dynamic Structure

Now we give a complete description of the fully-dynamic data structure for vertical ray shooting queries. Deletions are also implemented using bufferization: deleted segments are inserted into deletion buffers ${\cal D}(\nu)$ that are kept in the nodes of trees ${\cal P}(u)$. Deletion buffers are processed similarly to the insertion buffers. There are, however, a number of details that were not addressed in the previous section. When a new bridge $E_{i}$ is inserted we need to change weights for a number of segments. When the segment $n(u)$ is found, we need to find the bridges $b_{p}(u)$ and $b_{n}(u)$. The complete solution that addresses all these issues is more involved. First, we apply weighted search only to segments from $E(u)=\cup_{i=1}^{r}E_{i}(u)$. We complete the search and find the successor segment in $AC(u)$ using some auxiliary sets stored in the nodes of ${\cal P}(u)$. Second, we use a special data structure to find the bridges $b_{p}(u)$ and $b_{n}(u)$. We start by describing the changed structure of weighted trees ${\cal P}(u)$.

Segments stored in the leaves of ${\cal P}(u)$ are divided into weighted and unweighted segments. Weighted segments are segments from $E(u)$, i.e., weighted segments are used as down-bridges. All other segments are unweighted. Every leaf contains $\Theta(r^{2})$ weighted segments. There are at $\Omega(r^{2})$ and $O(r^{4})$ unweighted segments between any two weighted segments. Hence the total number of segments in a leaf is between $\Omega(r^{4})$ and $O(r^{6})$. Only weighted segments in a leaf have non-zero weights. Weights of weighted segments are computed in the same way as explained in Section 3. Hence the weight of a leaf $\lambda$ is the total weight of all weighted segments in $\lambda$. The search for a successor of $q$ in ${\cal P}(u)$ is organized in such way that it ends in the leaf holding the successor of $q$ in $E(u)$. Then we can find the successor of $q$ in $AC(u)$ using auxiliary data stored in the nodes of ${\cal P}(u)$.

We keep the following auxiliary sets and buffers in nodes $\nu$ of every weighted tree ${\cal P}(u)$. Let $AC_{fl}(u,\nu)$ denote the set of segments from $AC_{fl}(u)$ that are stored in leaf descendants of a node $\nu$.

• (i)

Sets $\operatorname{Max}_{fl}(\nu)$ and $\operatorname{Min}_{fl}(\nu)$ for all $f,l$ such that $1\leq f\leq l\leq r$ and for all nodes $\nu$. $\operatorname{Max}_{fl}(\nu)$ ($\operatorname{Min}_{fl}(\nu)$) contains $\min(r^{4},|AC_{fl}(u,\nu)|)$ highest (lowest) segments from $AC_{fl}(u,\nu)$. For every segment $s$ in sets $\operatorname{Max}_{fl}(\nu)$ and $\operatorname{Min}_{fl}(\nu)$ we record the index $i$ such that $s\in E_{i}(u)$ (or NULL if $s$ is not a bridge segment).

• (ii)

The set $\operatorname{Nav}(\nu)$ for an internal node $\nu$ is the union of all sets $\operatorname{Max}_{fl}(\nu_{i})$ and $\operatorname{Min}_{fl}(\nu_{i})$ for all children $\nu_{i}$ of $\nu$.

• (iii)

The set $\operatorname{Max}^{\prime}_{fl}(\nu)$, $1\leq f\leq l\leq r$ contains highest segments from $AC_{fl}(u,\nu)$ that are not stored in any set $\operatorname{Max}^{\prime}(u,\mu)$ for an ancestor $\mu$ of $\nu$. Either $\operatorname{Max}^{\prime}_{fl}(\nu)$ holds at least $r^{4}$ and at most $2r^{4}$ segments or $\operatorname{Max}^{\prime}_{fl}(\nu)$ holds less than $r^{4}$ segments and $\operatorname{Max}^{\prime}_{fl}(\rho)$ for all descendants $\rho$ of $\nu$ are empty. In other words, $\operatorname{Max}^{\prime}_{fl}(\cdot)$ are organized as external priority search trees [6]. The set $\operatorname{Min}^{\prime}_{fl}(\nu)$ is defined in the same way with respect to the lowest segments. We use $\operatorname{Max}^{\prime}$ and $\operatorname{Min}^{\prime}$ to maintain sets $\operatorname{Max}$ and $\operatorname{Min}$.

• (iv)

Finally we keep an insertion buffer ${\cal B}(\nu)$ and a deletion buffer ${\cal D}(\nu)$ in every node $\nu$.

Deletions. If an old segment $s$ is deleted, we insert it into the deletion buffer ${\cal D}(\nu_{R})$ of the root node $\nu_{R}$. If a new segment $s$ is deleted, we split $s$ into $O(r)$ unit segments and insert them into ${\cal D}(\nu_{R})$. When one or more segments are inserted into ${\cal D}(\nu_{r})$, we also update sets $\operatorname{Max}_{fl}(\nu_{R})$ and $\operatorname{Min}_{fl}(\nu_{R})$. For any node $\nu\in{\cal P}(u)$, when the number of segments in ${\cal D}(\nu)$ exceeds $r^{3}$, we flush both ${\cal D}(\nu)$ and ${\cal B}(\nu)$ using the following procedure. First we identify segments $s\in{\cal B}(\nu)\cap{\cal D}(\nu)$ and remove such $s$ from both ${\cal B}(\nu)$ and ${\cal D}(\nu)$. Next we move segments from ${\cal B}(\nu)$ and ${\cal D}(\nu)$ to buffers ${\cal B}(\nu_{i})$ and ${\cal D}(\nu_{i})$ in the children $\nu_{i}$ of $\nu$. For every child $\nu_{i}$ of $\nu$, first we update sets $Max^{\prime}_{fl}(\nu_{i})$ by removing segments from ${\cal D}(\nu_{i})$ (resp. inserting segments from ${\cal B}(\nu_{i})$) if necessary. Then we take care that the size of $\operatorname{Max}^{\prime}_{fl}(\nu_{i})$ is not too small. If some $\operatorname{Max}^{\prime}_{fl}(\nu_{i})$ contains less than $r^{4}$ segments and more than [math] segments, we move up segments from the children of $\nu_{i}$ into $\nu_{i}$, so that the total size of $\operatorname{Max}^{\prime}_{fl}(\nu_{i})$ becomes equal to $2r^{4}$ or all segments are moved from the corresponding sets $\operatorname{Max}^{\prime}_{fl}(\cdot)$ in the children of $\nu_{i}$ into $\operatorname{Max}^{\prime}_{fl}(\nu_{i})$. We recursively update $\operatorname{Max}^{\prime}_{fl}(\cdot)$ in each child of $\nu_{i}$ using the same procedure.

Next, we update sets $\operatorname{Max}_{fl}(\nu_{i})$. We compute ${\cal M}_{fl}=\cup\operatorname{Max}^{\prime}_{fl}(\mu)$ where the union is taken over all proper ancestors $\mu$ of $\nu$. Every segment in $\operatorname{Max}_{fl}(\nu)$ is either from $\operatorname{Max}^{\prime}_{fl}(\nu)$ or from $\operatorname{Max}^{\prime}_{fl}(\mu)$ for a proper ancestor $\mu$ of $\nu$. Hence we can compute all $\operatorname{Max}_{fl}(\nu_{i})$ when ${\cal M}_{fl}$ and $\operatorname{Max}^{\prime}_{fl}(\nu_{i})$ are known. Sets $\operatorname{Min}^{\prime}_{fl}(\nu_{i})$ and $\operatorname{Min}_{fl}(\nu_{i})$ are updated in the same way. Finally we update the set $\operatorname{Nav}(\nu)$ by collecting segments from $\operatorname{Max}_{fl}(\nu_{i})$ and $\operatorname{Min}_{fl}(\nu_{i})$.

All segments needed to re-compute sets after flushing buffers ${\cal D}(\nu)$ and ${\cal B}(\nu)$ fit into one block of space. Hence we can compute the set ${\cal M}$ in $O(\log_{B}n)=O(r)$ I/Os and all sets in each node $\nu_{i}$ in $O(1)$ I/Os. The set $\operatorname{Nav}(\nu)$ is updated in $O(r)$ I/Os. Since each node has $O(r)$ children, the total number of I/Os needed to flush a buffer is $O(r)$. Every segment can be divided into up to $r$ unit segments and each unit segment can contribute to $\log_{B}n$ buffer flushes. Hence the total amortized cost per segment is $O(\frac{r^{2}\log_{B}n}{r^{3}})=O(1)$. We did not yet take into account the cost of refilling the buffers $\operatorname{Max}^{\prime}$; using the analysis similar to the analysis in [12, Section 4], we can estimate the cost of re-filling $\operatorname{Max}^{\prime}$ as $O(\frac{\log_{B}n}{r^{3}})=o(1)$.

We do not store buffers in the leaf nodes. Let $S(\lambda)$ be the set of segments kept in a leaf $\lambda$ and let $S_{W}(\lambda)$ be the set of weighted segments stored in $\lambda$. When we move segments from ${\cal B}(\nu)$ or ${\cal D}(\nu)$ to its leaf child $\lambda$, we update $S(\lambda)$ accordingly. This operation changes the weight of $\lambda$. Hence we need to update the weighted tree ${\cal P}(u)$ in $O(\log n)$ I/Os. Sets $\operatorname{Max}_{fl}(\cdot)$ and $\operatorname{Min}_{fl}(\cdot)$ are also updated.

After an insertion of new segments into a leaf node, we may have to insert or remove some bridges in $E_{i}(u)$ for $1\leq i\leq r$. When we insert a new bridge $b$ into $E_{i}(u)$, we must split some portion ${\cal P}(u_{i})$ into two new portions, ${\cal P}_{1}(u_{i})$ and ${\cal P}_{2}(u_{i})$. Additionally we must change the weights of the bridge segments in $E_{i}(u)$ that precede and follow $b$. The cost of splitting ${\cal P}(u_{i})$ is $O(\log n)$. We also need $O(\log n)$ I/Os to change the weights of two neighbor bridges. Hence the total cost of inserting a new bridge is $O(\log n)$. We insert a bridge at most once per $O(r)$ insertions into $AC(u)$ because every new segment is divided into up to $r$ unit segments. We remove a bridge at most once after $O(r)$ deletions. See [13] for the description of the method to maintain bridges in catalogs $AC(u)$. Thus the total amortized cost incurred by a bridge insertion or deletion is $O(\frac{\log n}{r})=O(1)$.

Insertions. Insertions are executed in a similar way. A new inserted segment is split into $O(r)$ unit segments that are inserted into the buffer ${\cal B}(\nu_{R})$ for the root node $\nu_{R}$. The buffers and auxiliary sets are updated and flushed in the same way as in the case of deletions. When the number of new segments in some portion ${\cal P}(u)$ is equal to $n_{\mathtt{old}}/r$, where $n_{\mathtt{old}}$ is the number of old segments in ${\cal P}(u)$, we rebuild ${\cal P}(u)$. As explained in Section 4, rebuilding of ${\cal P}(u)$ incurs an amortized cost of $o(1)$.

Queries. The search for the successor segment $n(u)$ in the weighted tree ${\cal P}(u)$ consists of two stages. Suppose that the query point $q$ is in the slab of the $i$-th child $u_{i}$ of $u$. First we find the successor $b_{n}(u)$ of $q$ in $E_{i}(u)$ by searching in ${\cal P}(u)$. We traverse the path from the root to the leaf $\lambda_{n}$ holding $b_{n}(u)$. In every node $\nu$ we select its leftmost child $\nu_{j}$, such that $\operatorname{Max}_{fl}(\nu_{j})$ for some $f\leq i\leq l$ contains a segment $s$ that is above $q$ and $s$ is not deleted (i.e., $s\not\in{\cal D}(\mu)$ for all ancestors $\mu$ of $\nu$). The size of each set $\operatorname{Max}_{fl}(\nu_{k})$ is larger than the total size of all ${\cal D}(\mu)$ in all ancestors $\mu$ of $\nu$. Hence every $\operatorname{Max}_{fl}(\nu_{i})$ contains some elements that are not deleted unless the set $C_{fl}(u,\nu_{i})$ is empty. Therefore we select the correct child $\nu_{j}$ in every node. Since ${\cal P}(u)$ is a biased search tree [10, 19], the total cost of finding the leaf $\lambda_{n}$ is bounded by $O(\log(W_{P}/\omega_{\lambda}))=O(\log(W_{P}/\omega_{n}))$ where $\omega_{\lambda}$ is the total weight of all segments in $\lambda_{n}$ and $\omega_{n}\leq\omega_{\lambda}$ is the weight of the bridge segment $b_{n}(u)$.

During the second stage we need to find the successor segment $n(u)$ of $q$ in $AC(u)$. The distance between $n(u)$ and $b_{n}(u)$ in $AC(u)$ can be arbitrarily large. Nevertheless $n(u)$ is stored in one of the sets $\operatorname{Nav}(\mu)$ for some ancestor $\mu$ of $\lambda_{n}$. Suppose that $n(u)$ is an unweighted segment stored in a leaf $\lambda^{\prime}$ of ${\cal P}(u)$ and let $\mu$ denote the lowest common ancestor of $\lambda$ and $\lambda^{\prime}$. Let $\mu_{k}$ be the child of $\mu$ that is an ancestor of $\lambda^{\prime}$. There are at most $r^{4}$ segments in $AC_{fl}(u)$ between $n(u)$ and $b_{n}(u)$. Hence, $n(u)$ is stored in the set $\operatorname{Max}_{fl}(\mu_{k})$. Hence, $n(u)$ is also stored in $\operatorname{Nav}(\mu)$. We visit all ancestors $\mu$ of $\lambda_{n}$ and compute ${\cal D}=\cup_{\mu}{\cal D}(\mu)$. Then we visit all ancestors one more time and find the successor of $q$ in $\operatorname{Nav}(\mu)\setminus{\cal D}$. The asymptotic query cost remains the same because we only visit the nodes between $\lambda_{n}$ and the root and each node is visited a constant number of times.

We need to consider one additional special case. It is possible that there are no bridge segments $s\in E_{i}(u)$ stored in the leaves of ${\cal P}(u)$. In this case there are at most $r^{2}$ segments in $AC_{fl}(u)$ for every pair $f,\,l$, satisfying $f\leq i\leq l$, stored in the leaves of ${\cal P}(u)$. For each portion ${\cal P}(u)$, if there are at most $r^{2}$ segments in $AC_{fl}(u)\cap{\cal P}(u)$, we keep the list of all such segments. All such lists fit into one block of memory. We also keep the list of indexes $i$, such that $E_{i}(u)\cap{\cal P}(u)$ is empty.Suppose that we need to find the successor of $q$ and ${\cal P}(u)\cap E_{i}(u)$ is empty. Then we simply examine all segments in $AC_{fl}(u)\cap{\cal P}(u)$ for all $f\leq i\leq l$ and find the successor of $q$ in $O(1)$ I/Os.

When $n(u)$ is known, we need to find $b_{p}(u)$ and $b_{n}(u)$, if $b_{n}(u)$ was not computed at the previous step. It is not always possible to find these bridges using ${\cal P}(u)$ because $b_{p}(u)$ and $b_{n}(u)$ can be outside of ${\cal P}(u)$. To this end, we use the data structure for colored union-split-find problem on a list (list-CUSF) that will be described in Section B.1. We keep the list $V(u)$ containing all down-bridges from $E_{i}(u)$, for $1\leq i\leq r$, and all up-bridges from $UP(u)$. Each segment in $e\in V(u)$ is associated to an interval; a segment $e\in V_{i}(u)$ is associated to an interval $[i,i]$ and a segment from $UP(u)$ is associated to a dummy interval $[-1,-1]$. For any segment $e\in V(u)$ we can find the preceding/following segment associated to an interval $[i,i]$ for any $i$, $1\leq i\leq r$, in $O(\log\log_{B}n)$ I/Os. Updates of $V(u)$ are supported in $O(\log\log_{B}n)$ I/Os. Since we insert or remove bridge segments once per $r^{2}$ updates, the amortized cost of maintaining the list-CUSF structure is $O(1)$.

Summing up. By the same argument as in Section 3, weighted searches in all nodes take $O(\log_{B}n)$ I/Os in total. Additionally we spend $(\log\log_{B}n)$ I/Os in every node with a query to list-CUSF. Thus the total query cost is $O(\log_{B}n\log\log_{B}n)$. When a segment is deleted, we remove it from $O(\log_{B}n)$ lists $AC(u)$ and from secondary structures (weighted trees etc.) in these nodes. The deletions take $O(1)$ I/Os per node or $O(\log_{B}n)$ I/Os in total. When a segment is inserted, it must be inserted into $O(\log_{B}n)$ lists $AC(u)$. We first have to spend $O(\log_{B}n)$ I/Os to find the portion ${\cal P}(u)$ of each $AC(u)$ where it must be stored. When ${\cal P}(u)$ is known, an insertion takes $O(1)$ amortized I/Os as described above. The total cost of an insertion is $O(\log^{2}_{B}n)$ I/Os. Since every segment is stored in $O(\log_{B}n)$ lists, the total space is $O(n\log_{B}n)$.

Lemma 2

If $B>\log^{8}n$, then there exists an $O(n\log_{B}n)$ space data structure that supports vertical ray shooting queries on a dynamic set of $n$ non-intersecting segments in $O(\log_{B}n\log\log_{B}n)$ I/Os. Insertions and deletions of segments are supported in $O(\log^{2}_{B}n)$ and $O(\log_{B}n)$ amortized I/Os respectively.

6 Faster Insertions

When a new segment $s$ is inserted into our data structure, we need to find the position of $s$ in $O(\log_{B}n)$ lists $AC(u)$ (to be precise, we need to know the portion ${\cal P}(u)$ of $AC(u)$ that contains $s$). When positions of $s$ in $AC(u)$ are known, we can finish the insertion in $O(\log_{B}n)$ I/Os. In order to speed-up insertions, we use the multi-colored segment tree of Chan and Nekrich [13]. Segments in lists $C(u)$ are assigned colors $\chi$, so that the total number of different colors is $O(\log H)$ where $H=O(\log_{B}n)$ is the height of the segment tree. Let $C_{\chi}(u)$ denote the set of segments of color $\chi$ in $C(u)$. We apply the technique of Sections 3- 5 to each color separately. That is, we create augmented lists $AC_{\chi}(u)$ and construct weighted search trees ${\cal P}_{\chi}(u)$ for each color separately. The query cost is increased by factor $O(\log H)$, the number of colors. The deletion cost is also increased by $O(\log H)$ factor because we update the data structure for each color separately. When a new segment $s$ is inserted, we insert it into some lists $AC_{\chi_{i}}(u_{i})$ where $u_{i}$ is the node such that $s$ spans $u_{i}$ but does not span its parent and $\chi_{i}$ is some color (the same segment can be assigned different colors $\chi_{i}$ in different nodes $u_{i}$). We can find the position of $s$ in all $AC_{\chi_{i}}(u_{i})$ with $O(\log_{B}n\log H+H\cdot t_{\mathtt{usf}})=O(\log_{B}n\log\log_{B}n)$ I/Os where $t_{\mathtt{usf}}=O(\log\log_{B}n)$ is the query cost in a union-split-find data structure in the external memory model. See [13] for a detailed description.

Lemma 3

If $B>\log^{8}n$, then there exists an $O(n\log_{B}n)$ space data structure that supports vertical ray shooting queries on a dynamic set of non-intersecting segments in $O(\log_{B}n(\log\log_{B}n)^{2})$ I/Os. Insertions and deletions of segments can be supported in $O(\log_{B}n\log\log_{B}n)$ amortized I/Os.

7 Missing Details

Using the method from [13] we can reduce the space usage of our data structure to linear at the cost of increasing the query and update complexity by $O(\log\log_{B}n)$ factor.The resulting data structure supports queries in $O(\log_{B}n(\log\log_{B}n)^{2})$ I/Os and updates in $O(\log_{B}n(\log\log_{B}n)^{3})$ amortized I/Os. See Section A for a more detailed description.

In our exposition we assumed for simplicity that the tree ${\cal T}$ does not change, i.e., the set of $x$-coordinates of segment endpoints is fixed and known in advance. To support insertions of new $x$-coordinate, we can replace the static tree ${\cal T}$ with a weight-balanced tree with node degree $\Theta(r)=\Theta(B^{\delta})$. We also assumed that the block size $B$ is large, $B>\log^{8}n$. If $B\leq\log^{8}n$, the linear-space internal memory data structure [13] achieves $O(\log n(\log\log n)^{2})=O(\log_{B}n(\log\log_{B}n)^{3})$ query cost and $O(\log n\log\log n)=O(\log_{B}n(\log\log_{B}n)^{2})$ update cost because $\log n=O(\log_{B}n\log\log_{B}n)$ and $\log\log n=O(\log\log_{B}n)$ for $B\leq\log^{8}n$. Thus we obtain our main result.

Theorem 1

There exists an $O(n)$ space data structure that supports vertical ray shooting queries on a dynamic set of $n$ non-intersecting segments in $O(\log_{B}n(\log\log_{B}n)^{3})$ I/Os. Insertions and deletions of segments are supported in $O(\log_{B}n(\log\log_{B}n)^{2})$ amortized I/Os.

Appendix A Saving Space

We use another method from [13] to reduce the space usage of the data structure in Lemma 3 to linear.

Lemma 4** ([13], Lemma 3.1)**

Consider a decomposable search problem, where (i) there is an $S(n)$-space fully dynamic data structure with $Q(n)$ query cost and $U(n)$ update cost, and (ii) there is an $S_{D}(n)$-space deletion-only data structure with $Q_{D}(n)$ query cost, $U_{D}(n)$ update cost, and $P_{D}(n)$ preprocessing cost. Then there is an $O(S(n/z)+S_{D}(n))$-space fully dynamic data structure with $O(Q(n/z)+Q_{D}(n)\log z)$ query cost and $O(U(n/z)+U_{D}(n)+(P_{D}(n)/n)\log z)$ amortized update cost for any given parameter $z$ (assuming that $P_{D}(n)/n$ is nondecreasing).

Lemma 5** ([13], Lemma 3.1)**

If there is a deletion-only data structure for vertical ray shooting queries for $n$ horizontal segments with $S_{\mbox{\scriptsize\rm orth}}(n)$ space, $Q_{\mbox{\scriptsize\rm orth}}(n)$ query cost, $U_{\mbox{\scriptsize\rm orth}}(n)$ update cost, and $P_{\mbox{\scriptsize\rm orth}}(n)$ preprocessing cost, then there is a deletion-only data structure for vertical ray shooting queries for $n$ arbitrary non-intersecting segments with $S_{D}(n)=S_{\mbox{\scriptsize\rm orth}}(n)+O(n)$ space, $Q_{D}(n)=Q_{\mbox{\scriptsize\rm orth}}(n)+O(\log n)$ query cost, $U_{D}(n)=U_{\mbox{\scriptsize\rm orth}}(n)+O(1)$ update cost, and $P_{D}(n)=P_{\mbox{\scriptsize\rm orth}}(n)+O(n\log_{B}n)$ preprocessing cost.

The two above lemmata are obtained by a straightforward extension of Lemmata 3.1 and 3.2 from [13] to the external memory model. We will describe in Section B.3 a data structure that supports vertical ray shooting queries on a set of horizontal segments in $O(\log_{B}n\log\log_{B}n)$ I/Os and updates within the same amortized bounds. If we plug this result into Lemma 5, we obtain a deletion-only data structure for ray shooting queries in a set of $n$ arbitrary non-intersecting segments with $Q_{D}(n)=O(\log_{B}n\log\log_{B}n)$ query cost, $U_{D}(n)=O(\log_{B}n\log\log_{B}n)$ deletion cost, and $P_{D}(n)=O(n\log_{B}n\log\log_{B}n)$ preprocessing cost. Recall that the structure of Lemma 3 has query cost $Q(n)=O(\log_{B}n(\log\log_{B}n)^{2})$, update cost $U(n)=O(\log_{B}n\log\log_{B}n)$ I/Os amortized, and space usage $O(n\log_{B}n)$. We apply Lemma 4 to the structure of Lemma 3 and the deletion-only structure described above. We obtain the following lemma.

Lemma 6

If $B>\log^{8}n$, then there exists an $O(n)$ space data structure that supports vertical ray shooting queries on a dynamic set of $n$ non-intersecting segments in $O(\log_{B}n(\log\log_{B}n)^{3})$ I/Os. Insertions and deletions of segments are supported in $O(\log_{B}n(\log\log_{B}n)^{2})$ amortized I/Os.

Appendix B Ray Shooting on Horizontal Segments

In this section we describe a data structure for vertical ray shooting queries in a dynamic set of horizontal segments. A data structure for this problem can be used to answer dynamic point location queries in an orthogonal subdivision. The special case of horizontal segments is much simpler than the ray shooting among arbitrary segments because it is easy to maintain the order among horizontal segments. Our solution is based on a colored variant of the predecessor search, described in Section B.1. We describe how this data structure can be combined with the segment tree to answer ray shooting queries in Section B.2. We show that the space usage of our data structure can be reduced from $O(n\log_{B}n)$ to $O(n)$ in Section B.3.

B.1 Colored Predecessor Search in External Memory

In the colored predecessor searching problem, every element $e=(v_{e},I_{e})$ has a value $v_{e}$ and color interval $I_{e}=[c_{1},c_{2}]$, $1\leq c_{1}\leq c_{2}\leq C$. We assume that color intervals are disjoint for elements with the same value, i.e., if $v_{a}=v_{b}$ for two elements $a$ and $b$, then $I_{a}\cap I_{b}=\emptyset$. The answer to a colored predecessor query $(v_{q},{\cal C}_{q})$ for $v_{q}\in[1,V]$ and ${\cal C}_{q}\subset[1,C]$ is the largest (with respect to its value $v_{e}$) element $e$, such that $v_{e}\leq v_{q}$ and ${\cal C}_{q}\cap I_{e}\not=\emptyset$. We say than an element $e$ is colored with a color $c$ if $c\in I_{e}$. First, we show how colored search queries for a small set of elements can be answered with a constant number of I/Os. Then, we will describe a data structure for an arbitrarily large set of elements.

Lemma 7

Let $\delta>0$ and $0<f\leq 1-\delta$. The colored predecessor searching problem for a set $S_{l}$, such that colors of elements belong to $[1,C]$ for $C\leq B^{f}$, can be solved in $O(\log_{B}|S_{l}|)$ I/Os using a $O(|S_{l}|)$ space data structure that supports updates in $O(\log_{B}|S_{l}|)$ I/Os.

• Proof: We sort the elements in $S_{l}$ by their values (elements with the same value are sorted by the smallest colors that belong to their color intervals) and store them in the leaves of a tree $T_{l}$. Each leaf contains $\Theta(B)$ elements of $S_{l}$ and each internal node has $\rho=\Theta(B^{\delta})$ children. We say that an internal node $u$ contains an element $s$ if $s$ is stored in a leaf descendant of $u$. In every internal node $u$, we store a table $R_{u}$: for each $c\in[1,C]$ and each $1\leq i\leq\rho$, $R_{u}[c,i]=1$ iff the $i$-th child of $u$ contains at least one element with color $c$. For every $(c,i)$ such that $R_{u}[c,i]=1$, we also store the maximal and the minimal elements colored with $c$ that belong to the $i$-th child of $v$. Every table $R_{u}$ fits into $O(1)$ blocks. There are $O(|S_{l}|/B)$ internal nodes in $T_{l}$; hence, all $R_{u}$ use $O(|S_{l}|)$ words of space.

The search for $(x_{q},c_{q})$ starts at the root of $T_{l}$. In each visited node $u$ of $T$, we identify the rightmost child $u_{i}$ such that $R_{u}[c_{q},i]=1$ for some $c_{q}\in{\cal C}_{q}$ and the minimal element colored with $c_{q}$ in $u_{i}$ is not greater than $x_{q}$. If such $u_{i}$ does not exist, then $S_{l}$ contains no element colored with $c_{q}\in{\cal C}_{q}$ that is smaller than or equal to $x_{q}$. Otherwise, the search continues in $u_{i}$. The height of $T_{l}$ is $O(\log_{B}|S_{l}|)$ and the search takes $O(\log_{B}|S_{l}|)$ I/Os.

When a new element is inserted into $S_{l}$, we insert it into a leaf $u$ of $T_{l}$. Then, we visit all ancestors $u^{\prime}$ of $u$ and update the tables $R_{u^{\prime}}$. The tree $T_{l}$ can be rebalanced in a standard way. Deletions are processed with a symmetric procedure.    $\Box$

Lemma 8

Let $0<f<1/2$. A colored searching problem for a set of $K$ elements, such that values of elements belong to the universe $[1,V]$ and colors belong to the interval $[1,C]$ for $C\leq B^{f}$, can be solved in $O(\log\log_{B}V)$ I/Os using a $O(\max(V,K)\log\log_{B}V)$ space data structure that supports updates in $O(\log\log_{B}V)$ amortized I/Os.

• Proof: To simplify the description, we introduce a new set of interval colors ${\cal M}$: for each interval $[c_{1},c_{2}]$, $1\leq c_{1}\leq c_{2}\leq C$, there is an interval color $c_{12}\in{\cal M}$. Thus each interval color corresponds to a color interval $I_{e}$. Obviously, for each original color $c_{i}$ there is the interval color that corresponds to the interval $[c_{i},c_{i}]$. An element $e$ is colored with a color from a set ${\cal C}_{q}$ if and only if $e$ is colored with an interval color from a set ${\cal M}_{q}=\{\,c_{ij}\,|\,\exists c\in{\cal C}_{q},\,c_{i}\leq c\leq c_{j}\,\}$. For every set of colors ${\cal C}_{q}$ the equivalent set of interval colors ${\cal M}_{q}$ can be constructed in $O(1)$ I/Os. While each element $e$ is colored with colors from an interval $I_{e}$, each $e$ is colored with only one interval color.

The data structure can be defined recursively. If $\max(K,V)\leq B^{2}$, we can use the data structure of Lemma 7 and answer queries in $O(1)$ I/Os. If $\max(K,V)>B^{2}$, then we divide the interval $[1,V]$ into subintervals of size777For ease of description we assume that $h$ is an integer. $B^{h}$ for $h=(\log_{B}V)/2$. The array $A[r]$ contains two tables $\min[i,j]$ and $\max[i,j]$ for each subinterval. The table $A[r].\min[i,j]$ ($A[r].\max[i,j])$ contains the minimal (maximal) element in the $r$-th subinterval colored with an interval color $c_{ij}$. If there is no such element in the $r$-th subinterval, then $A[r].\min[i,j]=A[r].\max[i,j]=\mathtt{NULL}$. Let $S[r][i,j]$ be the set of elements whose values belong to the subinterval $[(r-1)B^{h}+1,rB^{h}]$ and whose interval color is $[i,j]$. If $|S[r][i,j]|\leq 2$, the values of elements from $S[r][i,j]$ are already stored in $A[r].\min[i,j]$ and $A[r].\max[i,j]$. If $|S[r][i,j]|\geq 3$ for at least one pair $i,j$, we construct a recursively defined data structure $D[r]$ for $S[r]$. All values of elements in $D[r]$ are specified relative to the left end of the $r$-th subinterval; thus values of all elements in $D[r]$ belong to $[1,B^{h}]$. The data structure $D_{top}$ supports colored predecessor searching in the array $A$: if $A[r].\min[i,j]\not=\mathtt{NULL}$, then $D_{top}$ contains an element $e$ with $v_{e}=r$ and $I_{e}=\{c_{ij}\}$, i.e. $e$ is colored with an interval color $c_{ij}$. Values of elements in $D_{top}$ also belong to the interval $[1,B^{h}]$. All tables $\min[]$ and $\max[]$ in the array $A$ have $O(B^{\log_{B}V/2}\cdot B^{2f})$ entries. Therefore $A$ uses $O(\max(K,V))$ words of space. Since values of elements in $D_{top}$ and $D_{r}$ belong to $[1,B^{\log_{B}V/2}]$, there are at most $O(\log\log_{B}V)$ recursion levels. Hence, the total space usage is $O((\max(K,V)/B)\log\log_{B}V)$.

A query $(v_{q},{\cal C}_{q})$ is processed as follows. Let ${\cal M}_{q}$ be the set of interval colors that is equivalent to ${\cal C}_{q}$. If $K\leq B^{2}$, the query is answered in $O(1)$ I/Os by Lemma 7. Otherwise we check whether there is at least one pair $i,j$ such that $A[v^{\prime}_{q}].\min[i,j]\leq v_{q}$ and $[i,j]\cap{\cal C}_{q}\not=\emptyset$; here $v^{\prime}_{q}$ denotes the index of the subinterval that contains $v_{q}$. This condition can be tested in $O(1)$ I/Os because each entry of $A[]$ fits into one block of memory. If such a pair exists, the search continues in the data structure $D[v^{\prime}_{q}]$. Otherwise, we use the data structure $D_{top}$ to find the largest $r^{\prime}<v^{\prime}_{q}$ such that $r^{\prime}$ is colored with a color $c_{ij}\in{\cal M}_{q}$. The answer to the query is the maximal element among all $A[r^{\prime}].\max[i,j]$ such that $c_{ij}\in{\cal M}_{q}$.

Suppose that $\max(V,K)\geq B^{2}$ and an element $e=(v_{e},[i_{e},j_{e}])$ is inserted. We update the values of $A[r].\min[i,j]$ and $A[r].\max[i,j]$ for $r=v_{e}/B^{h}$ if necessary. If $|S[r][i,j]|\geq 3$ after the insertion of $e$, we insert an element $(v,[i,j])$, such that $v\not=A[r].\min[i,j]$ and $v\not=A[r].\max[i,j]$ into $D[r]$. If $|S[r][i,j]|=1$ after the insertion of $e$, we insert an element $(r,[i,j])$ into the data structure $D_{top}$. Deletions are symmetric to insertions.    $\Box$

In the colored union-split-find (CUSF) problem we put an additional restriction on queries: only queries $(v_{q},{\cal C}_{q})$, such that there is an element $e\in S$ with value $v_{e}=v_{q}$, are allowed. Moreover, we assume that a pointer to such an element $e\in S$ is provided with a query. When an element $e$ is deleted or inserted, we assume that the position of $e$ is known.

Lemma 9

The CUSF problem for a set of $K$ elements and $C\leq B^{1-f}$, $0<f<1$, colors can be solved in $O(\log\log_{B}K)$ I/Os using a $O(K)$ space data structure that supports updates in $O(\log\log_{B}K)$ amortized I/Os.

• Proof: We can transform the general searching data structure into a CUSF data structure using the same principle as in [20]. The set of $K$ elements is divided into chunks of size $\Theta(g)$. If $B\geq\log^{2}K$, then we set $g=B^{1+2f}$. Otherwise, we set $g=\log_{B}^{4}K$. We assign to each chunk $m$ an ordered label $\mathtt{lab}(m)\in[1,O(K)]$: if the chunk $m_{1}$ follows $m_{2}$, then $\mathtt{lab}(m_{1})>\mathtt{lab}(m_{2})$. Labels can be maintained according to the algorithm of [24, 28]: when a new chunk is inserted or when a chunk is deleted, $O(\log^{2}K)$ labels must be changed. The set of interval colors ${\cal M}$ is defined exactly as in the proof of Lemma 8. The data structure $D_{v}$ contains an element $(\mathtt{lab}(m),c_{ij})$ if and only if the chunk $m$ contains an element with color interval $I_{e}=[c_{i},c_{j}]$. By Lemma 8, $D_{v}$ uses $O(K)$ words of space. We also store a data structure $D_{m}$ for each chunk that supports colored predecessor searching queries in this chunk. We implement the data structure $D_{m}$ as described in Lemma 7, so that colored searching queries are supported in $O(\log_{B}g)=O(\log_{B}\log_{B}K)$ I/Os. All data structures $D_{m}$ use space $O(K)$.

Consider a query $(v_{q},{\cal C}_{q})$. Suppose that some element $e\in S$ with $v_{e}=v_{q}$ belongs to a chunk $m_{e}$. First, we find the largest chunk $m$, such that $m$ contains at least one interval color $c_{ij}$ and $[c_{i},c_{j}]\cap{\cal C}_{q}\not=\emptyset$. The set of colors ${\cal M}_{q}=\{\,c_{ij}\,|\,\exists c\in{\cal C}_{q},\,c_{i}\leq c\leq c_{j}\,\}$ can be constructed with $O(1)$ I/Os. Using $D_{v}$, we can answer the colored search query for $(m_{e},{\cal M}_{q})$ and find the chunk $m$ in $O(\log\log_{B}K)$ I/Os. The largest element $e$ with $v_{e}\leq v_{q}$ and $I_{e}\cap{\cal C}_{q}\not=\emptyset$ belongs to the chunk $m$. The cost of finding $e$ using the data structure for the chunk $m$ is $O(\log_{B}\log_{B}K)$; hence, a query can be answered with $O(\log\log_{B}K)$ I/Os.

When a new element $e$ is inserted, we insert it into a chunk $m_{e}$ in $O(1)$ I/Os. If the data structure $D_{v}$ does not contain the element $(\mathtt{lab}(m_{e}),I_{e})$, then we insert this element into $D_{v}$ in $O(\log\log_{B}K)$ I/Os. If the number of elements in a block equals $2g$ we distribute the elements of $m$ between two chunks $m_{1}$ and $m_{2}$. It takes $O(g\log_{B}g)$ I/Os to delete the data structure $D_{m}$ and insert the elements of $m$ into data structures $D_{m_{1}}$ and $D_{m_{2}}$. We assign new labels to chunks $m_{1}$ and $m_{2}$ and update the set of labels. This leads to changing the labels of $O(\log^{2}_{2}K)$ chunks. The data structure $D_{v}$ contains $O(B^{2f})$ labels for each chunk. Hence, the total number of updates in $D_{v}$ incurred by updating the set of labels is $O(B^{2f}\log^{2}K)$. If $B>\log^{2}_{2}K$, then $B^{1+2f}>B^{2f}\log^{2}K$. If $B\leq\log^{2}K$, then $\log_{B}^{4}K=\Omega(B^{2f}\log^{2}_{2}K)$. Since labels are changed after $\Theta(g)=\Omega(B^{2f}\log^{2}_{2}K)$ insertions, the amortized cost of an insertion is $O(\log\log_{B}K)$. Deletions are performed in the same way. Thus the total cost of an update is $O(\log\log_{B}K)$.    $\Box$

We remark that, in fact, the values of elements are not necessary. Using the same method, we can store a list of elements, such that each element $e$ in the list is assigned an interval of colors $I_{e}$. Given a pointer to a list element $e$ and a color interval ${\cal C}_{q}$, we ask for the first element $e^{\prime}$ that follows $e$ in the list and ${\cal C}_{q}\cap I_{e^{\prime}}\not=\emptyset$. We will call this problem list CUSF.

Lemma 10

The list CUSF problem for a set of $K$ elements and $C\leq B^{1-f}$, $0<f<1$, colors can be solved in $O(\log\log_{B}K)$ I/Os using a $O(K)$ space data structure that supports updates in $O(\log\log_{B}K)$ amortized I/Os.

This result can be proved in the same way as Lemma 9; we use it in Section 5.

B.2 Ray Shooting on Horizontal Segments

Structure. All segments are stored in a tree ${\cal T}$ with node degree $B^{c}$ for some constant $c<1/2$. The leaves of ${\cal T}$ contain $x$-coordinates of segment endpoints; every leaf contains $\Theta(B)$ elements. The tree is organized as a variant of the segment tree, in the same way as in Section 2.1. We start by introducing some additional notation. The range of a leaf node $v_{l}$ is the interval $[a_{l},b_{l}]$, where $a_{l}$ and $b_{l}$ are the minimal and the maximal values stored in $v_{l}$. The range of an internal node $v$ is the interval $[a,b]$, so that $a$ and $b$ are the minimal and maximal values stored in leaf descendants of $v$.

We say that a segment $s=(x_{1},x_{2};y)$ covers an interval $[a,b]$ if $x_{1}\leq a$ and $b\leq x_{2}$; a segment covers $a$ if it covers an interval $[a,a]$. Thus a segment spans a node $v$ if it covers the range of $v$. We implement ${\cal T}$ in the same way as before: a segment $s=(x_{1},x_{2};y)$ is associated with a node $v$ if and only if $s$ spans at least one child $v_{i}$ of $v$, but $s$ does not span the node $v$. Thus each segment is associated with $O(\log_{B}n)$ nodes.

Let $C(v)$ be the set of segments associated with a node $v$. For simplicity, we sometimes will not distinguish between a segment and its $y$-coordinate. For any point $q=(q_{x},q_{y})$, let $\pi$ denote search path for $q_{x}$ in the tree ${\cal T}$. Each segment $s=(x_{1},x_{2};y_{s})$, $x_{1}\leq q_{x}\leq x_{2}$, is stored in a list $C(v)$, $v\in\pi$. If $s\in C(v)$ covers $q_{x}$ and $v$ is an internal node, then $s$ spans the child $v_{i}$ of $v$, $v_{i}\in\pi$. Hence, we can identify the predecessor segment $s_{q}$ of $q$ by finding the highest segment $s\in C(v)$, $v\in\pi$, such that $s$ spans some node $v^{\prime}\in\pi$ and $y_{s}\leq q_{y}$.

Our method is based on Lemma 9 and the fractional cascading technique [25] applied to sets $C(v)$. We construct augmented catalogs $AC(v)\supset C(v)$ for all nodes $v$ of ${\cal T}$. For a leaf node $v_{l}$, $AC(v_{l})=C(v_{l})$. Every list $AC(v)$ is divided into groups $G_{1}(v),G_{2}(v),\ldots$, so that each group contains between $\log_{B}n/2$ and $2\log_{B}n$ segments. We guarantee that $AC(v)$ for an internal node $v$ contains one segment from a group $G_{j}(v_{i})$ for every child $v_{i}$ of $v$ and every group $G_{j}(v_{i})$. Moreover, $AC(v)$ contains all segments from $C(v)$. If copies of the same segment $s$ are stored in augmented lists for a node $v$ and for a child $v_{i}$ of $v$, then the two copies of $s$ in $AC(v)$ and $AC(v_{i})$ are connected by pointers, called bridges. Thus there are $O(\log_{B}n)$ elements of $AC(v_{i})$ between any two consecutive bridges from $AC(v)$ to $AC(v_{i})$.

The data structure $D(v)$ contains the colored set of ($y$-coordinates of) all segments in $AC(v)$: if a segment $s=(x_{1},x_{2};y_{s})\in C(v)$ spans children $v_{i},v_{i+1},\ldots,v_{j}$ of $v$, then an element $e_{s}=(y_{s},[i,j])$ with value $y_{s}$ and colors $I_{e}=[i,j]$ is stored in $D(v)$; if a segment $s$ does not span any child $v_{i}$ of $v$ (i.e., $s$ belongs to $AC(v)\setminus C(v)$), then $e_{s}$ is colored with a dummy color $c_{d}$. The data structure $E(v)$ also contains a colored set of segments in $AC(v)$, but segments are colored according to a different rule. All segments from $C(v)$ are colored with a dummy color $c_{d}$; for any segment $s\in AC(v)\setminus C(v)$, the set of colors for $s$ contains all values $i$ such that $s$ belongs to $AC(v_{i})$ for a child $v_{i}$ of $v$. Both $D(v)$ and $E(v)$ are implemented as described in Lemma 9.

Queries. The search procedure visits all nodes on the path $\pi$ starting at the root. In every internal node $v\in\pi$, we identify the predecessor $s(v)$ of $q.y$ in $AC(v)$. Then we identify the highest segment $s^{\prime}(v)$ in $AC(v)$ such that $s^{\prime}(v)$ is below $s(v)$ and $s^{\prime}(v)$ spans the child $v_{i}$ of $v$, $v_{i}\in\pi$. Finally, we examine all segments in the leaf $v_{l}\in\pi$ and find the predecessor segment $s^{\prime}(v_{l})$ of $q$ stored in $C(v_{l})$. The predecessor segment of $q$ in $S$ is the highest segment among all $s^{\prime}(v)$ for $v\in\pi$.

We can identify $s(v)$ for the root of ${\cal T}$ in $O(\log_{B}n)$ I/Os using a standard B-tree. Suppose that $s(v)$ for a node $v$ is known. We will show how to find $s^{\prime}(v)$ and $s(v_{i})$ for the child $v_{i}\in\pi$ of $v$. The highest segment $s^{\prime}(v)\in AC(v)$, such that $s^{\prime}(v)$ is below $s(v)=(x_{1},x_{2};y_{s})\in AC(v)$ and $s^{\prime}(v)$ spans a child $v_{i}$ of $v$ can be found by answering the query $(y_{s},i)$ to a data structure $D(v)$. The segment $s(v_{i})$ can be identified as follows. The highest segment $s_{1}(v)$, such that $s_{1}(v)$ is below $s(v)$ and $s_{1}(v)$ belongs to $AC(v_{i})$ can be found in $O(\log\log_{B}n)$ I/Os using $E(v)$. Suppose that the copy of $s_{1}(v)$ belongs to a group $G_{j}(v_{i})$ in $AC(v_{i})$. Since $s_{1}(v)$ is the highest segment below $q$ in $AC(v)\cap AC(v_{i})$, $s(v_{i})$ either belongs to the group $G_{j}(v_{i})$ or to the next group $G_{j+1}(v_{i})$. If we store $y$-coordinates of all segments from each group $G_{l}$ in a B-tree, then we can search in $G_{l}$ in $O(\log_{B}\log_{B}n)$ I/Os because each $G_{l}$ contains $O(\log_{B}n)$ segments. Thus the segment $s(v_{i})$ can be found in $O(\log_{B}\log_{B}n)$ I/Os if $s_{1}(v)$ is known. Since the search procedure spends $O(\log\log_{B}n)$ I/Os in every node of $\pi$, the total cost of the search is $O(\log_{B}n\log\log_{B}n)$.

Updates. Every segment belongs to $O(\log_{B}n)$ lists $C(v)$. Every insertion into a list $C(v)$ can be handled as follows. All nodes $v$ such that $s$ belongs to $C(v)$ are situated on at most two root-to-leaf paths $\pi$. We can identify positions of the $y$-coordinate of $s$ in all $AC(v)$ that belong to some path $\pi$ in $O(\log_{B}n\log\log_{B}n)$ I/Os as described in the search procedure.

When we know the position of $s$ in a list $AC(v)$, we insert $s$ into data structures $D(v)$ and $E(v)$ in $O(\log\log_{B}n)$ I/Os. We also insert $s$ into the B-tree for its group $G_{j}$ in $C(v)$. If the number of elements in $G_{j}$ exceeds $2\log_{B}n$, $G_{j}$ is split into two groups $G^{\prime}_{j}(v)$ and $G^{\prime\prime}_{j}(v)$. The list $AC(w)$ for the parent $w$ of $v$ already contains one element from either $G^{\prime}_{j}(v)$ or $G^{\prime\prime}_{j}(v)$. A representative $s_{r}$ of another group must be inserted into $AC(w)$. The position of $s_{r}$ in $AC(w)$ can be found in $O(\log\log_{B}n)$ I/Os; after that, $s_{r}$ is inserted into $AC(w)$ in $O(\log\log_{B}n)$ I/Os as described above. It can be shown that an insertion into a catalog $AC(v)$ leads to $O(1/\log_{B}n)$ insertions into augmented lists of ancestors of $v$ [25]. Hence, the total cost of an insertion is $O(\log_{B}n\log\log_{B}n)$. Deletions can be handled in the same way. Since every segment is stored in $O(\log_{B}n)$ nodes, the total space usage is $O(n\log_{B}n)$.

Lemma 11

There exists a $O(n\log_{B}n)$ space data structure that supports ray shooting queries on horizontal segments in $O(\log_{B}n\log\log_{B}n)$ I/Os and updates in $O(\log_{B}n\log\log_{B}n)$ amortized I/Os.

We can reduce the space usage to linear using the same approach as in [9, 20]. For completeness, we provide the proof in Section B.3.

Theorem 2

There exists a $O(n)$ space data structure that supports ray shooting queries on horizontal segments in $O(\log_{B}n\log\log_{B}n)$ I/Os and updates in $O(\log_{B}n\log\log_{B}n)$ amortized I/Os.

B.3 Reducing Space to Linear

We follow the same approach as in [9, 20]. For a segment $s=(x_{f},x_{e};y_{s})$, let $v_{s}$ be the lowest common ancestor of the leaves in which $x_{f}$ and $x_{e}$ are stored. The node $v_{s}$ is the lowest node such that the range of $v$ contains $[x_{f},x_{e}]$, but $[x_{f},x_{e}]$ does not span $v$. Suppose that $s$ spans the children $v_{i},\ldots,v_{j}$ of $v$. We represent $s$ as a union of three segments: $s_{m}=(a_{i},b_{j};y_{s})$, $s_{l}=(x_{f},a_{i};y_{s})$, and $s_{r}=(b_{j},x_{e};y_{s})$, where $rng(v_{i})=[a_{i},b_{i}]$ and $rng(v_{j})=[a_{j},b_{j}]$. Segments $s_{m}$, $s_{l}$ and $s_{r}$ are stored in sets $S_{m}(v)$, $S_{l}(v_{i-1})$, and $S_{r}(v_{j+1})$ respectively. Let $\Pi_{m}=\cup_{v\in{\cal T}}S_{m}(v)$, $\Pi_{l}=\cup_{v\in{\cal T}}S_{l}(v)$, and $\Pi_{r}=\cup_{v\in{\cal T}}S_{r}(v)$. A ray shooting query can be answered by answering a ray shooting query for $\Pi_{m}$, $\Pi_{r}$, and $\Pi_{l}$.

We can identify the predecessor segment of $q$ in $\Pi_{m}$ by storing all segments $s\in\Pi_{m}$ in the data structure of section B.2. Since every segment is stored only once the total space usage is $O(n)$. Now we describe the data structure for $\Pi_{r}$. A query on $\Pi_{l}$ can be answered using a symmetrically defined data structure.

Each set $S_{r}(v)$ is divided into blocks ${\cal W}$, so that each block contains $\Theta(\log_{B}n)$ segments. We denote by $win({\cal W})$ the segment in a block ${\cal W}$ with the largest $x$-coordinate of the right endpoint. The segments $win({\cal W})$ for all blocks ${\cal W}$ and all sets $S_{r}(u)$ are stored in a data structure $D_{r}$ implemented as in section B.2. Since the total number of segments in $D_{r}$ is $O(n/\log_{B}n)$, $D_{r}$ needs $O(n)$ words. We denote by $Y_{r}(u)$ the set of $y$-coordinates of all segments in $S_{r}(u)$. The data structure $D_{y}$ is defined on all sets $Y_{r}(u)$. Let $u_{i}$ denote the nodes that lie on some root-to-leaf path of ${\cal T}$. Using $D_{y}$, we can search in all sets $Y_{r}(u_{i})$ in $O(\log\log_{B}n)$ I/Os per node. To implement $D_{y}$, we apply the construction of section B.2, i.e., the augmented sets and CUSF structures, to sets $Y_{r}(u)$. Finally, for each block ${\cal W}$ we store a data structure that supports queries on segments of ${\cal W}$ in $O(\log_{B}(|{\cal W}|))$ I/Os. This data structure uses the fact that the left endpoints of all segments in ${\cal W}$ lie on the same vertical line and is very similar to an external memory priority search tree [6].

A point location query for $q=(q_{x},q_{y})$ on $\Pi_{r}$ can be answered as follows. We start by identifying the successor segment $s^{+}$ of $q$ in $D_{r}$ and the predecessor segment $s^{-}$ of $q$ in $D_{r}$. Let $y^{+}$ and $y^{-}$ denote the $y$ coordinates of $s^{+}$ and $s^{-}$. Then, we use the data structure $D_{y}$ and find $y_{1}(u)=\mathrm{pred}(y^{-},Y(u))$ and $y_{2}(u)=\mathrm{succ}(y^{+},Y(u))$ for every node $u\in\pi$, where $\pi$ is the search path for $q_{x}$ in ${\cal T}$. The following fact is proved in [20].

Fact 1

Let ${\cal W}_{1}(u)$ and ${\cal W}_{2}(u)$ be the blocks in $S_{r}(u)$ that contain segments with $y$-coordinates $y_{1}(u)$ and $y_{2}(u)$ respectively. Let $s^{*}$ be the predecessor segment of $q$ in $\Pi_{r}$. Then $s^{*}$ belongs to a block ${\cal W}_{1}(u)$ or ${\cal W}_{2}(u)$ for some $u\in\pi$.

We can complete the search by querying all ${\cal W}_{1}(u)$ and ${\cal W}_{2}(u)$, $u\in\pi$, in $O(\log_{B}n\log_{B}\log_{B}n)$ I/Os and selecting the highest segment among all answers.

When a new segment is inserted, we identify the node $v_{s}$ in $O(\log_{B}n)$ I/Os. Insertion of $s_{m}$ into $\Pi_{m}$ is handled as in section B.2. Insertion of $s_{r}$ starts with identifying the child $v_{r}$ of $v_{s}$ such that $rng(v_{r})$ intersects with $[x_{f},x_{e}]$ but $s$ does not span $v_{r}$. Let ${\cal W}_{s}$ be the block of $S_{r}(v_{r})$ into which $s$ must be inserted. If the $x$-coordinate of the right endpoint of $s$ is larger than the $x$-coordinate of $win({\cal W}_{s})$, then we remove $win({\cal W}_{s})$ from $D_{r}$ and insert $s$ into $D_{r}$. We also insert the $y$-coordinate of $s$ into $D_{y}$. Finally, if the number of elements in ${\cal W}_{s}$ after an insertion equals $2\log_{B}n$, then ${\cal W}_{s}$ is split into two blocks that contain $\log_{B}n$ segments each. We can show using standard methods that the amortized cost of splitting a block is $O(\log_{B}\log_{B}n)$. An insertion into $\Pi_{l}$ is symmetric. Hence, the total cost of an insertion is $O(\log_{B}n\log\log_{B}n)$. Deletions can be implemented in the same way.

Appendix C Weighted Telescoping Search: Simplified Scenario

In this section we provide a simple alternative description of our main technique, the weighted telescoping search. This section is not necessary in order to understand the material in the rest of this paper; the only purpose of this section is to provide a simple description of the weighted telescoping search. To introduce our technique, we digress from the point location problem and consider the following more simple scenario. Suppose that we are given a balanced tree ${\cal T}$ of node degree $r$ and we keep a list (or catalog) $L(u)$ in every node $u$ of ${\cal T}$. We assume that elements of $L(u)$ are numbers. The successor of $q$ in a set $S$ is the smallest element $e$ in $S$ that is larger than or equal to $q$, $\mathrm{succ}(q,S)=\min\{\,e\in S\,|\,e\geq q\,\}$. Suppose that we want to traverse a path $\pi(\ell)$ from the root of ${\cal T}$ to a leaf $\ell$ and search for the successor of some $q$ in the union of all lists $L(u)$ along the path. In other words, for any element $q$ and any leaf $\ell$ we want to quickly find $\mathrm{succ}(q,\cup_{u\in\pi(\ell)}L(u))$. This problem can be solved using the standard fractional cascading technique [15] within the same time, but in this paper we describe an alternative solution. We also believe that this general technique can be used in other scenarios when the standard fractional cascading is hard to apply. Unlike the rest of this paper, in this section we describe the solution for the internal memory model.

Our solution is based on assigning weights to elements of $L(u)$ and maintaining a forest of weighted trees on each list $L(u)$ for every node $u\in{\cal T}$. Roughly speaking, we choose the weights in such a way that the weight of an element $e\in L(u)$ gives us an estimate on the number of elements $e^{\prime}$, such that $e^{\prime}$ is stored in $L(v)$ for some descendant $v$ of $u$ and $pred(e,L(u))\leq e^{\prime}\leq e$. We keep augmented catalogs $AL(u)\supseteq L(u)$ in order to compute and maintain element weights.

Augmented Lists. We maintain an augmented catalog $AL(u)$ in every node $u$. Augmented catalogs are supersets of $L(u)$, $AL(u)\supseteq L(u)$, that satisfy the following properties:

• (i)

If $e\in(AL(u)\setminus L(u))$, then $e\in L(v)$ for an ancestor $v$ of $u$.

• (ii)

Let a subset $E_{i}(u)$ of $AL(u)$ be defined as $E_{i}(u)=AL(u)\cap AL(u_{i})$ for a child $u_{i}$ of $u$. There are at most $d=O(r^{2})$ elements of $AL(u)$ between any two consecutive elements of $E_{i}(u)$.

Elements of $E_{i}(u)$ for some $1\leq i\leq r$ will be called down-bridges; elements of the set $UP(u)=AL(u)\cap AL(\mathit{par}(u))$, where $\mathit{par}(u)$ denotes the parent node of $u$, are called up-bridges. We will say that a sub-list of a catalog $AL(u)$ bounded by two up-bridges is a portion of $AL(u)$. We can create and maintain augmented lists $AL(u)$ using the fractional cascading technique [15, 25]. The main idea is to copy selected elements from $L(u)$ and store the copies in lists $AL(v)$ for descendants $v$ of $u$; see e.g., [13] for a detailed description. If the same element $e$ is stored in lists $AL(u)$ and $AL(\mathit{par}(u))$, where $\mathit{par}(u)$ is the parent node of $u$, then we assume that there are pointers between instances of $e$ in $AL(u)$ and $AL(\mathit{par}(u))$.

Element weights. We assign the weight to each element of $AL(u)$ in a bottom-to-top manner: for a leaf node $\ell$ every element $e\in AL(\ell)$ is assigned weight $1$. Consider an internal node $u$ with children $u_{1}$, $\ldots$, $u_{r}$. We associate values $weight_{i}(e,u)$ with each $e\in AL(u)$ for every $i$, $1\leq i\leq r$. Let $e_{1}$ and $e_{2}$ denote two consecutive bridge elements in $E_{i}(u)$. Let $W(e_{1},e_{2},u)=\sum_{e_{1}\leq e^{\prime}\leq e_{2}}weight(e^{\prime},u)$ denote the total weight of all elements $e^{\prime}\in AL(u)$ such that $e_{1}<e^{\prime}\leq e_{2}$. Every element $e\in AL(u)$ that satisfies $e_{1}<e\leq e_{2}$ is assigned the same value of

[TABLE]

The weight of $e\in AL(u)$ is defined888We observe that the same element $e$ can be assigned different weights $weight(e,u)$ in different nodes $u$. as $weight(e,u)=\sum_{i=1}^{r}weight_{i}(e,u)$.

Telescoping Search. Consider a sub-list ${\cal P}(u)$ of the augmented catalog $AL(u)$ bounded by two up-bridges. All elements of ${\cal P}(u)$ are stored in a weighted search tree satisfying the following property: The depth of a leaf holding an element $e\in{\cal P}(u)$ is bounded by $O(\log(W_{P}/weight(e)))$ where $W_{P}=\sum_{e^{\prime}\in{\cal P}(u)}weight(e^{\prime})$ is the total weight of all elements in ${\cal P}(u)$. We can use e.g. biased search trees [10, 19] for this purpose.

Now suppose that we want to find, for some number $q$ and some leaf $\ell$ of ${\cal T}$, the successor of $q$ in $\cup_{u\in\pi(\ell)}L(u)$ where $\pi(\ell)$ is the path from the root to $\ell$. We start in the root node $u_{0}$ and identify $n(u_{0})=\mathrm{succ}(q,AL(u_{0}))$. Suppose that $u_{1}$ is the $j$-th child of $u_{0}$. We find the largest down-bridge $b_{p}(u_{0})\leq n(u_{0})$ and the smallest down-bridge $b_{n}(u_{0})\geq n(u_{0})$ where $b_{p}\in E_{j}(u_{0})$ and $b_{n}\in E_{j}(u_{0})$. We use finger search [23] in $AL(u_{0})$ with $n(u_{0})$ as a finger to find $b_{n}(u_{0})$ and $b_{p}(u_{0})$ in $O(\log r)$ time. Next we identify the portion ${\cal P}(u_{1})$ bounded by $b_{p}(u_{0})$ and $b_{n}(u_{0})$. We find $n(u_{1})=\mathrm{succ}(q,AL(u_{1}))$ by searching in the weighted tree for ${\cal P}(u_{1})$. We then find the largest $b_{p}(u_{1})\leq n(u_{1})$ and the smallest $b_{n}(u_{1})\geq n(u_{1})$ where $b_{p}\in E_{g}(u_{1})$, $b_{n}\in E_{g}(u_{1})$ and $u_{2}$ is the $g$-th child of $u_{1}$. Again we use finger search and find $b_{n}(u_{1})$, $b_{p}(u_{1})$ in $O(\log r)$ time. We continue in the same way until the leaf node is reached. See Fig. 6.

When we know $\mathrm{succ}(q,AL(u_{i}))$ for every node $u_{i}\in\pi(\ell)$, $n^{*}=\mathrm{succ}(q,\cup_{u_{i}\in\pi(\ell)}AL(u_{i}))$ can be computed. Every element $e\in AL(u)$ is either from the set $L(u)$ or from the set $L(w)$ for some ancestor $w$ of $u$. Hence $\cup_{u\in\pi(\ell)}AL(u)=\cup_{u\in\pi(\ell)}L(u)$. Hence $n^{*}$ is the successor of $q$ in $\cup_{u\in\pi(\ell)}L(u)$.

The total time can be estimated as follows. Let $\omega_{i}$ denote the weight of $n(u_{i})$. We can find the element $e_{n}(u_{0})$ in time $\log(W_{0}/\omega_{0})$, where $W_{0}$ is the total weight of all elements in $AL(u_{0})$. Down-bridges $b_{p}(u_{0})$ and $b_{n}(u_{0})$ can be found in $O(\log r)$ time by finger search in $AL(u_{0})$. When we know $b_{p}(u_{i})$ and $b_{n}(u_{i})$, we can compute $n(u_{i+1})$ in time $O(\log(W_{i+1}/\omega_{i+1}))$ where $W_{i+1}$ is the total weight of all elements in ${\cal P}(u_{i+1})$. When $n(u_{i+1})$ is known, we can compute $b_{p}(u_{i+1})$ and $b_{n}(u_{i+1})$ in $O(\log r)$ time. The total time needed to compute all $n(u_{i})$ is $O(\sum_{i=0}^{h}\log(W_{i}/\omega_{i}))$ where $h$ is the tree height. Since $\omega_{i}\geq W_{i+1}/r^{2}$, we have

[TABLE]

By definition, $\omega_{h}=1$. We will show below that $W_{0}\leq n$. Since $h=\log_{r}n$, $2(h+1)\log r=O(\log n)$ and the sum above can be bounded by $O(\log n)$. All finger searches also take $O(\log n)$ time.

It remains to prove that $W_{0}\leq n$. We will show by induction that the total weight of all elements on every level of ${\cal T}$ is bounded by $n$: Every element in a leaf node has weight $1$; hence their total weight does not exceed $n$. Suppose that, for some $k\geq 1$, the total weight of all elements on level $k-1$ does not exceed $n$. Consider an arbitrary node $v$ on level $k$, let $v_{1}$, $\ldots$, $v_{r}$ be the children of $v$, and let $m_{i}$ denote the total weight of elements in $AL(v_{i})$. Every element in $AL(v_{i})$ contributes $1/d$ fraction of its weight to at most $d$ different elements in $AL(v)$. Hence $\sum_{e\in AL(v)}weight_{i}(v)\leq m_{i}$ and the total weight of all elements in $AL(v)$ does not exceed $\sum_{i=1}^{r}m_{i}$. Hence, for any level $k\geq 1$, the total weight of $AL(v)$ for all nodes $v$ on level $k$ does not exceed $n$. Hence the total weight of $AL(u_{0})$ for the root node $u_{0}$ is also bounded by $n$.

Thus we have shown the following result.

Lemma 12

Suppose that we store a sorted list $L(u)$ in every node $u$ of a balanced degree-$r$ tree ${\cal T}$. Then it is possible to find $\mathrm{succ}(q,\cup_{u\in\pi}L(u))$ for any $q$ and for any root-to-leaf path $\pi$ in $O(\log n)$ time, where $n$ is the total size of all lists $L(u)$. The underlying data structure uses space $O(n)$.

It is possible to extend the result of this section to the external memory model and to dynamize our data structure. However Lemma 12 cannot be used to answer vertical ray shooting queries because in the scenario of this Lemma lists $L(u)$ contain numbers.