Almost Optimal Exact Distance Oracles for Planar Graphs

The planar distance oracle problem was introduced in 1996 by Arikati et al. [3] and Djidjev [24]. The main technical tool used in the early planar distance oracles [3, 19, 24] is Lipton and Tarjan’s planar separator theorem [49], and its refinements by Miller [52] and Frederickson [29]. Let the query time and the space of an oracle be denoted by Q and S, respectively. The early oracles achieved a space-query tradeoff of \(Q=\tilde{O}(n/\sqrt {S})\) for \(S\in [n^{4/3},n^2]\) but a weaker tradeoff of \(Q=O(n^2/S)\) for \(S \in [n,n^{4/3})\) .

In a very influential article Fakcharoenphol and Rao [28] introduced Monge matrices to planar graph algorithms and devised a distance oracle with \(\tilde{O}(n)\) space and \(\tilde{O}(\sqrt {n})\) query time; i.e., they added an additional point to the general \(Q=\tilde{O}(n/\sqrt {S})\) tradeoff. Eventually, Mozes and Sommer [54] extended this tradeoff to nearly the full range \([n\log \log n, n^2]\) , using [28] and ideas from Klein’s [44] multiple source shortest path (MSSP) data structure.

The work of [30, 54, 56, 67] focused on achieving optimal time or space at the expense of the other measure. Wulff-Nilsen’s [67] distance oracle occupies subquadratic space \(O(n^2\log ^4\log n/\log n)\) and answers queries in optimal \(O(1)\) time, whereas Nussbaum [56] and Mozes and Sommer’s [54] distance oracle occupies optimal \(O(n)\) space and answers distance queries in \(O(n^{1/2+\epsilon })\) time, for any \(\epsilon \gt 0\) . On undirected, unweighted planar graphs, the recent distance oracle of Fredslund-Hansen et al. [30] occupies \(O(n^{5/3+\epsilon })\) space and answers queries in \(O(\log (1/\epsilon))\) time for any \(\epsilon \gt 0\) .

In 2017 Cabello [10] introduced a new idea, additively weighted planar Voronoi diagrams,¹ and used them to solve problems concerning planar metrics (diameter, sum-of-distances) in strongly subquadratic time. Inspired by this idea, Cohen-Addad et al. [20] realized that Voronoi diagrams can be used to obtain the first exact distance oracle for planar graphs with subquadratic space and polylogarithmic query time. The Voronoi diagram-based oracle in their breakthrough paper has a space-time tradeoff of \(Q=\tilde{O}(n^{5/2}/S^{3/2})\) for \(S\in [n^{3/2},n^{5/3}]\) .

All of the distance oracles cited above report exact distances. Thorup [63] proved that on non-negatively weighted planar graphs, \((1+\epsilon)\) -approximate distances can be reported in \(O(\epsilon ^{-1}+\log \log n)\) time by an oracle of space \(O(n\epsilon ^{-1}\log ^2 n)\) . Refer to [13, 34, 42, 43, 44, 48, 68] for other space-time-approximation tradeoffs on undirected planar graphs and to [48] for an improved tradeoff on directed planar graphs. See Table 1.

In this article we show that there is no polynomial tradeoff between space and query time, and that near-optimality in both measures can be achieved simultaneously: with \(n^{1+o(1)}\) space exact distance queries can be answered in \(n^{o(1)}\) query time. Our main distance oracle (Theorem 1.1) does have a space-time tradeoff, the extremes of which let us achieve either \(\tilde{O}(n)\) space or \(\tilde{O}(1)\) query time but not both.

At a high level, Theorem 1.1 reduces a distance query \(\operatorname{dist}_G(u,v)\) to a series of point location problems in additively weighted planar Voronoi diagrams. We compute an m-level \(\vec{r}\) -division [29, 46] where regions on level i have \(O(n^{i/m})\) vertices and \(O(\sqrt {n^{i/m}})\) boundary vertices (vertices shared by other regions). In the course of answering a distance query \(\operatorname{dist}_G(u,v)\) we find \((u_1,u_2,\ldots)\) , where \(u_i\) is the last vertex of the shortest u-to-v path lying on the boundary of a level-i region that contains u.

Theorem 3.2 proves that the point location problem itself is reducible to \(O(\log n)\) distance-type queries² via a kind of binary search. We employ two strategies for answering these distance-type queries. The first is to store many MSSP structures for various subgraphs. This is time-efficient but requires space linear in the size of these subgraphs. The second is to use recursion. Specifically, given \((u_1,\ldots ,u_i)\) , we can narrow the number of possibilities for \(u_{i+1}\) down to two candidates \(s_1,s_2\) in \(\tilde{O}(1)\) time via point location queries that are solved without recursion. We determine which of these two sites actually is \(u_{i+1}\) with two recursive calls to compute \(\operatorname{dist}(s_1,v)\) and \(\operatorname{dist}(s_2,v)\) . This branching process leads to a query time \(\tilde{O}(2^m)\) that depends exponentially on m, whereas the space of the data structure is about \(\tilde{O}(n^{1+1/m})\) . Thus, by setting m appropriately, we can achieve \(\tilde{O}(1)\) query time and \(n^{1+o(1)}\) space or \(n^{o(1)}\) query time and \(\tilde{O}(n)\) space.

Using existing MSSP structures [44], the query time would be \(O(2^m \log ^3 n)\) . We develop a new MSSP data structure based on Euler-tour trees [38] and partially persistent arrays [21] that may be of independent interest. It uses \(O(\kappa n^{1+1/\kappa })\) space and answers distance-type queries in \(O(\kappa \log \log n)\) time, for any parameter \(\kappa \ge 1\) . The first tradeoff of Theorem 1.1 (minimizing query time) is obtained by setting both \(\kappa ,m\) to be \(\omega (1)\) and \(o(\log \log n)\) .

In Theorem 4.1 we describe a simpler distance oracle that achieves different space-time tradeoffs, namely \(\tilde{O}(n^{4/3})\) space and \(O(\log ^2 n)\) query time, or \(n^{4/3+o(1)}\) space and \(\log ^{1+o(1)} n\) query time.

Finally, we complement our almost optimal distance oracle with an efficient preprocessing algorithm that runs in \(n^{3/2+o(1)}\) time. In particular, we show an efficient algorithm for computing Voronoi diagrams in planar graphs, which we believe is of independent interest.

Provenance of the Article. This article is derived from three extended abstracts. The first [31], which appeared in SODA 2018, characterized the tree structure of the dual representation of Voronoi diagrams and developed the point location mechanism described in Section 3. The distance oracle of [31] achieved a tradeoff of \(Q=\tilde{O}(n^{3/2}/S)\) for \(S\in [n,n^{3/2}]\) , which is completely subsumed by Theorem 1.1. Therefore, it is not described in this article. The second paper [14], which appeared in STOC 2019, observed that the same point location mechanism can be used in an external Voronoi diagram, i.e., the Voronoi diagram for the complement of a region in an r-division. Furthermore, it developed the recursive query structure using m-level \(\vec{r}\) -divisions. A query at level i of the recursion reduces to \(O(\log n)\) queries at level \(i+1\) . Thus, the query time in [14] is proportional to \((\log n)^m\) rather than to \(2^m\) as in Theorem 1.1. The resulting distance oracle of [14] achieved \(n^{1+o(1)}\) space and \(n^{o(1)}\) query-time. The third paper [50], which appeared in SODA 2021, modified and extended the point location mechanism. It showed that, by using appropriate persistent data structures and further exploiting planarity, much of the point location work can be done efficiently without recursion, and that only two recursive calls at a higher level suffice. The MSSP data structure based on Euler-tour trees was also introduced in [50].

In Section 2 we review background on planar embeddings, planar separators, and MSSPs. In Section 3 we review additively weighted Voronoi diagrams and prove that the point location problem is reducible to \(O(\log n)\) distance-type queries. Section 4 describes a simple distance oracle with space \(\Omega (n^{4/3})\) and faster query times than those of Theorem 1.1.

Section 5 introduces the main distance oracle of Theorem 1.1 and the high-level query algorithm. The high-level algorithm relies on specialized point location routines, which are introduced in Section 6. Section 7 analyzes the space and query time of the distance oracle, whereas its construction time is addressed in Section 8. Section 9 explains how to remove a simplifying assumption made throughout the article, that each region is bounded by a single hole. We conclude with some remarks and open problems in Section 10.

The new MSSP implementation is described in Appendix A.

A weighted directed planar graph \(G=(V,E,\ell)\) is represented by a combinatorial embedding: for each \(v\in V(G)\) we list the edges incident to v according to the clockwise order around v. Let \(n=|V(G)|\) . We assume that the graph has a fixed embedding and has no negative weight cycles and, without loss of generality, further assume the following:

Suppose \(P=(v_0,v_1,\ldots ,v_k)\) is a path oriented from \(v_0\) to \(v_k\) , and \(e=(v_i,u)\) (where \(i\in [1,k-1]\) ) is an edge not on P. Then e is to the right of P if e appears between \(\lbrace v_i,v_{i+1}\rbrace\) and \(\lbrace v_{i-1},v_i\rbrace\) in the clockwise order around \(v_i\) , and left of P otherwise.

Lipton and Tarjan [49] proved that every planar graph contains a separator of \(O(\sqrt {n})\) vertices that, once removed, breaks the graph into components with at most \(2n/3\) vertices each. Miller [52] showed that every triangulated planar graph has a \(O(\sqrt {n})\) -size separator that consists of a simple cycle. Simple cycle separators can be used to recursively separate a planar graph until its components have constant size. Klein et al. [46] showed how to obtain, in \(O(n)\) time, a complete recursive decomposition tree of G that is a binary tree whose nodes correspond to subgraphs of G, called regions, with the root being all of G, and the leaves being regions of constant size. The set of boundary vertices of a region R is denoted by \(\partial R\) : it consists of those vertices of R that belong to some separator along the recursive decomposition used to obtain R.

An r-division, introduced by Frederickson [29], is a set of \(\Theta (n/r)\) regions, no two of which are ancestors of one another in the recursive decomposition tree, whose union is G (i.e., a maximal anti-chain), and such that each region has \(O(r)\) vertices and \(O(\sqrt {r})\) boundary vertices.

We use [46] for computing a hierarchical \(\vec{r}\) -division, where \(\vec{r}=(r_m,\ldots ,r_1)\) and \(n = r_m \gt \cdots \gt r_1 = \Omega (1)\) in linear time. Each region in each \(r_i\) -division is a region in the complete recursive decomposition tree of G. Such an \(\vec{r}\) -division has the following properties:

We modify the output of the Klein-Mozes-Sommer [46] \(\vec{r}\) -division in two ways. First, we supplement it with a zeroth level. The layer-0 \(\mathcal {R}_0 = \lbrace \lbrace v\rbrace \mid v\in V(G)\rbrace\) consists of singleton sets, and each \(\lbrace v\rbrace\) is attached as a (leaf) child of an arbitrary \(R\in \mathcal {R}_1\) for which \(v\in R\) . Second, we modify the graph so that every hole of every region is bounded by a simple cycle in the graph. This involves cutting along paths of repeated edges; see Section 9 for details of this transformation.

Suppose that f is one of the \(O(1)\) holes of region R and \(C_f\) is the cycle bounding f. The cycle \(C_f\) partitions \(E(G) - C_f\) into two parts. Let \(R^{f,\operatorname{out}}\) be the graph induced by the part disjoint from R, together with \(C_f\) ; i.e., \(C_f\) appears in both R and \(R^{f,\operatorname{out}}\) . The presentation of the algorithm is greatly simplified by assuming that in every region R, \(\partial R\) lies on a single hole \(f_R\) . We use \(R^{\operatorname{out}}\) as a short form of \(R^{f_R,\operatorname{out}}\) . In Section 9 we explain how to remove this assumption.

Consider a weighted planar graph H with a distinguished face f on vertices S. Klein’s MSSP algorithm [45] takes \(O(|H|\log |H|)\) time and produces an \(O(|H|\log |H|)\) -size data structure that, given \(s\in S\) and \(v\in V(H)\) , returns \(\operatorname{dist}_H(s,v)\) in \(O(\log |H|)\) time. Klein’s algorithm can be viewed [11] as continuously moving the source vertex around the boundary face f, recording all changes to the single-source shortest path (SSSP) tree in a Link-cut tree data structure [59]. It is shown [45] that each edge in H enters and leaves the SSSP tree exactly once, and hence the number of changes is \(O(|H|)\) . Each change to the tree can be handled in \(O(\log |H|)\) time [59], and the generic persistence method of [25] allows for querying any state of the SSSP tree. The important point is that the total space is linear in the number of updates to the structure ( \(O(|H|)\) ) times the update time ( \(O(\log |H|)\) ). We show that this structure can be augmented to also answer other useful queries. Further, we present alternative tradeoffs for the problem by implementing MSSP using Euler Tour trees [38], as opposed to the data structure of [45] that uses Link-cut trees [59]. Since our data structure (with Euler Tour trees) does not satisfy the criteria of Driscoll et al.’s [25] persistence method for pointer-based data structures, we use the folklore implementation of persistent arrays⁴ to make any RAM data structure persistent, with doubly logarithmic slowdown in the query time. See Appendix A for a proof of Lemma 2.1.

The purpose of the second query is to tell whether u lies on the shortest s-to-v path ( \(x=u\) ) or vice versa, or to tell whether the s-to-u path branches left or right from the s-to-v path. If they do branch, we also say that u is to the left/right of the s-to-v path. Once we retrieve the LCA x and edges \(e_u,e_v\) , we get the edge \(e_x\) from x to its parent. The clockwise order of \(e_x,e_u,e_v\) around x tells us⁵ whether the shortest s-to-u path branches to the left or to the right of the shortest s-to-v path. See Figure 2.

The point location problem is, given v and some representation of a Voronoi diagram \(\mathrm{VD}[H,S,{\rm \omega }]\) , to determine the site \(s\in S\) for which \(v\in \operatorname{Vor}(s)\) and the distance \(d^{\rm \omega }(s,v)\) . In this section we describe a data structure that answers point location queries efficiently, given access to an MSSP structure on the relevant graph.

In the remainder of this section we prove Theorem 3.2. The main idea is as follows. In order to find the Voronoi cell \(\operatorname{Vor}(s)\) to which a query vertex v belongs, it suffices to identify an edge \(e^*\) of \(\mathrm{VD}^*\) that is adjacent to \(\operatorname{Vor}(s)\) . Given \(e^*\) , we can simply check which of its two adjacent cells contains v by comparing the additive distances from the corresponding two sites to v using two MSSP queries. The point location data structure is based on a centroid decomposition of the tree \(\mathrm{VD}^*\) into connected subtrees and on the ability to go down this centroid decomposition, each time choosing a subtree that contains an edge adjacent to \(\operatorname{Vor}(s)\) .

We assume that H is triangulated, except for the face h. In addition, for technical reasons we assume that for every face \(f\ne h\) incident to \(\lbrace y_0,y_1,y_2\rbrace\) , three artificial vertices \(y^f_j\) , \(j\in \lbrace 0,1,2\rbrace\) have been embedded in f, each with a single zero-length incident edge \((y_j, y^f_j)\) .⁶ This assumption does not change distances in H or the asymptotic size of H. The preprocessing consists of just computing a centroid decomposition of \(\mathrm{VD}^*\) . A centroid of an n-node tree T is a node \(u\in T\) such that removing u and replacing it with copies, one for each edge incident to u, results in a set of trees, each with at most \(\frac{n+1}{2}\) edges. A centroid always exists in a tree with at least one edge. The centroid decomposition of \(\mathrm{VD}^*\) is defined recursively. In every step of the centroid decomposition we work with a connected subtree \(T^*\) of \(\mathrm{VD}^*\) . Initially, \(T^*\) is the entire tree \(\mathrm{VD}^*\) . Recall that there are no nodes of degree 2 in \(\mathrm{VD}^*\) . If there are no nodes of degree 3, then \(T^*\) consists of a single edge of \(\mathrm{VD}^*\) , and the decomposition terminates. Otherwise, we choose a centroid \(c^*\) and partition \(T^*\) into the three subtrees \(T^*_{0},T^*_{1},T^*_{2}\) obtained by splitting \(c^*\) into three copies, one for each edge incident to \(c^*\) . Since the size of \(\mathrm{VD}^*\) is \(O(|S|)\) , the depth of this recursive decomposition is \(\log |S|+O(1)\) . Such a decomposition can be computed in \(O(|S|)\) time [8, 33] and can be represented as a ternary tree, which we call the centroid decomposition tree, in \(O(|S|)\) space. Each non-leaf node of the centroid decomposition tree corresponds to a centroid vertex \(c^*\) , which is stored explicitly. We will refer to nodes of the centroid decomposition tree by their associated centroid. Each node also implicitly corresponds to the subtree of \(\mathrm{VD}^*\) of which \(c^*\) is the centroid. The leaves of the centroid decomposition tree correspond to single edges of \(\mathrm{VD}^*\) , which are stored explicitly. See Figure 4.

The procedure \(\boldsymbol {\mathsf {SimpleCentroidSearch}}(\mathrm{VD}^*,v)\) takes as input a dual Voronoi diagram \(\mathrm{VD}^*\) and a vertex v to be located. It returns a pair \((s,d),\) where \(v\in \operatorname{Vor}(s)\) and \(d=d^\omega (s,v)\) . The procedure is recursive. It traverses a centroid decomposition for \(\mathrm{VD}^*\) , and at intermediate invocations the procedure takes a third argument \(T^*\) , which is a subtree of the centroid decomposition. The loop invariant is that \(T^*\) contains a leaf representing some edge on the boundary of \(\operatorname{Vor}(s)\) . The algorithm bottoms out in one of two base cases (Line 8 or Line 13).

The first way the recursion can end is if we reach the bottom of the centroid decomposition. If \(T^*\) is a singleton, its single node \(f^*\) corresponds to an edge in \(\mathrm{VD}^*\) separating the Voronoi cells of two sites, say \(s_1\) and \(s_2\) . At this point we know that either \(v \in \operatorname{Vor}(s_1)\) or \(v \in \operatorname{Vor}(s_2)\) and determine which case is true by comparing the additive distances from each of \(s_1\) and \(s_2\) , which can be computed using the MSSP data structure (Lines 2–9).

We now explain how to treat the case where \(T^*\) is not a singleton. The root \(f^*\) of \(T^*\) is dual to a trichromatic face f composed of three vertices \(y_0,y_1,y_2\) in clockwise order, which are, respectively, in distinct Voronoi cells of sites \(s_0,s_1,s_2\) . Let \(e_0,e_1,e_2\) be the edges \(\lbrace y_2,y_0\rbrace ,\lbrace y_0,y_1\rbrace ,\lbrace y_1,y_2\rbrace\) , respectively. For \(j \in \lbrace 0,1,2\rbrace\) , let \(p_j\) denote the \(s_j\) -to- \(y_j\) shortest path. Further, let us denote by \(C_j\) the path obtained by concatenating path \(p_j\) , edge \(e_j\) , and the reverse of path \(p_{j-1}\) . (In notation related to a triangular face, all subscripts are naturally modulo 3; i.e., \(p_{j-1}\) is short for \(p_{j-1 \pmod 3}\) .) A vertex of H lies either on one of the \(p_j\) s or strictly to the right of exactly one of the \(C_j\) s. The second case can be equivalently restated as follows: v is enclosed by the cycle composed of \(C_j\) and the \(s_{j-1}\) -to- \(s_j\) walk along face h that does not contain \(s_{j+1}\) . See Figure 5.

For each j, we can check whether v lies on some \(p_j\) using the MSSP data structure. If this is the case, then \(v \in \operatorname{Vor}(s_j)\) , and we are done (Lines 12–13). We next show how to check whether v lies to the right of some \(C_j\) .

If it turns out that v is right of \(C_j\) , the algorithm recurses on the subtree of \(T^*\) rooted at the child of \(f^*\) that contains the leaf edge of \(\mathrm{VD}^*\) representing \(e^*_j\) (Line 16).

We are now ready to complete the proof of Theorem 3.2 on the correctness and time complexity of \(\boldsymbol {\mathsf {SimpleCentroidSearch}}\) . Define \(f,y_j,s_j,e_j^*,f^*,p_j,C_j\) , for \(j=\lbrace 0,1,2\rbrace\) as above, and let \(\tilde{s}\) be such that \(v\in \operatorname{Vor}(\tilde{s})\) . If Line 12 tells us that v is on \(p_j\) , then \(\tilde{s}\) is \(s_j\) , as returned in Line 13. The loop invariant is that \(T^*\) contains some leaf edge that belongs to the boundary of the cell \(\operatorname{Vor}(\tilde{s})\) . This is clearly true in the initial call, when \(T^*\) is the entire centroid decomposition of \(\mathrm{VD}^*\) . Suppose that Line 14 tells us that v lies strictly to the right of \(C_j\) . Observe that since \(p_j\) and \(p_{j-1}\) are monochromatic, all edges of \(\mathrm{VD}^*\) correspond to paths in \(H^*\) that are disjoint from the set of dual edges of \(C_j\) , with the exception of \(e_j^*\) . We claim that \(T_j^*\) contains at least one edge bounding \(\operatorname{Vor}(\tilde{s})\) . First, this is clearly true if \(e_j^*\) is such an edge, i.e., if \(\tilde{s} \in \lbrace s_{j-1},s_j\rbrace\) . In the complementary case, all vertices of \(\operatorname{Vor}(\tilde{s})\) are strictly to the right of \(C_j\) . Hence, none of the edges bounding \(\operatorname{Vor}(\tilde{s})\) can be in \(T^*_{j^{\prime }}\) for \(j^{\prime } \ne j\) . Thus, the maintained invariant implies that there is such an edge in \(T_j^*\) .

When \(f^*\) is a single edge on the boundary of \(\operatorname{Vor}(s_1)\) and \(\operatorname{Vor}(s_2)\) (Line 2), the loop invariant guarantees that either \(\tilde{s}=s_1\) or \(\tilde{s}=s_2\) . The additive distances \(d_1\) and \(d_2\) to \(s_1\) and \(s_2\) respectively are computed in Line 5, and \(\tilde{s}\) is the site with smaller additive distance among the two (Line 7). Hence, Line 8 returns the correct answer.

The efficiency of procedure \(\boldsymbol {\mathsf {SimpleCentroidSearch}}\) depends on the time required to compute distances in H (Lines 5 and 13) and whether v lies on or to the left/right of a shortest path \(p_j\) (Lines 12 and 14). By Lemmas 2.1 and 3.3, each of these operations is supported by the MSSP data structure for \(H,S\) , whose query time is \(t_q\) . Hence, the cost of the top-level call to \(\boldsymbol {\mathsf {SimpleCentroidSearch}}\) is \(O(t_q\cdot \log |S|)\) , \(O(t_q)\) time for each of the \(\log |S|+O(1)\) recursive calls.

We begin by computing an \(\vec{r}=(r_3,r_2,r_1)\) division, where \(r_3=n\) , \(r_2 \approx n^{2/3}\) , and \(r_1 \approx n^{1/3}\) . In other words, \(\mathcal {R}_3 = \lbrace G\rbrace\) contains one region, namely G, which is partitioned into regions \(\mathcal {R}_2\) , each with \(O(r_2)\) vertices and \(O(\sqrt {r_2})\) boundary vertices, and so on. As usual, we temporarily assume that each region is bounded by a single hole and remove this assumption in Section 4.4. The data structure consists of the following three parts:

The query algorithm \(\boldsymbol {\mathsf {SimpleDist}}(u,v,R_i)\) is recursive. It takes vertices \(u,v\in R_i \in \mathcal {R}_i\) and reports \(\operatorname{dist}_{R_i}(u,v)\) . At the top-level recursive call \(\boldsymbol {\mathsf {SimpleDist}}(u,v,G)\) we have \(i=3\) ( \(G\in \mathcal {R}_3\) is the only region at level 3), and when \(i=1,\) the distance can be reported immediately (Line 2) using part 1 of the data structure. Therefore, the recursion depth is constant.

When \(i\in \lbrace 2,3\rbrace ,\) we let \(R_{i-1}\) be a subregion of \(R_i\) containing u. There are two cases: \(v\in R_{i-1}\) or \(v\not\in R_{i-1}\) . When \(v\in R_{i-1}\) , the shortest u-to-v path can be contained entirely in \(R_{i-1}\) or it can cross \(\partial R_{i-1}\) . In the former case \(\operatorname{dist}_{R_i}(u,v)=\operatorname{dist}_{R_{i-1}}(u,v)\) , which is computed recursively (Line 6). In the latter case, suppose \(s\in \partial R_{i-1}\) is the last boundary vertex along the shortest u-to-v path. Thenwhere \(\omega\) is the additive weight function in \(\mathrm{VD}^*_{\operatorname{in}}(u,R_{i-1})\) . In other words, computing \(\operatorname{dist}_{R_i}(u,v)\) reduces to a point location problem in \(\mathrm{VD}^*_{\operatorname{in}}(u,R_{i-1})\) (Line 7). When \(v\not\in R_{i-1}\) , we know the shortest u-to-v path crosses \(\partial R_{i-1}\) at least once; suppose that the last time it crosses is at vertex s. Then, by similar reasoning,where \(\omega\) is the additive weight function from \(\mathrm{VD}^*_{\operatorname{out}}(u,R_{i-1})\) . This point location problem in \(\mathrm{VD}^*_{\operatorname{out}}(u,R_{i-1})\) is handled in Line 10.

The query time is dominated by \(O(1)\) point location queries. By Theorem 3.2, \(\boldsymbol {\mathsf {SimpleDist}}\) takes \(O(t_q \log n)\) time, where \(t_q \in \lbrace O(\log n), O(\kappa \log \log n)\rbrace\) depends on the MSSP implementation.

If we use the first implementation of MSSP from Lemma 2.1, the overall space is linear inwhich is \(O(n^{4/3}\log ^{2/3} n)\) when \(r_2=n^{2/3}\log ^{1/3} n\) and \(r_1 = n^{1/3}\log ^{2/3} n\) . The space can be reduced to \(O(n^{4/3}\log ^{1/3} n)\) by using a four-level \(\vec{r}\) -division, say, \(\vec{r}=(n,n^{2/3}\log ^{2/3} n, n^{(2/3)^2}, n^{(2/3)^3})\) . This increases the cost of distance queries by a small constant factor.

If we use the second implementation of MSSP from Lemma 2.1, with a space overhead of \(\rho = \kappa n^{1/\kappa }\) , the overall space is linear inwhich is \(O(n^{4/3}\rho ^{2/3})=O(\kappa ^{2/3} n^{4/3+2/(3\kappa)})\) when \(r_2 = n^{2/3}\rho ^{1/3}, r_1 = n^{1/3}\rho ^{2/3}\) . When query time is prioritized, it is best to set \(\kappa = \omega (1)\) and \(\log ^{o(1)} n\) , leading to a distance oracle with \(n^{4/3+o(1)}\) space and query time \(O((\kappa \log \log n)\cdot \log n) = \log ^{1+o(1)} n\) .

In general the boundary vertices \(\partial R_i\) of any region \(R_i\) lie on \(O(1)\) holes. We modify the data structure and query algorithm to deal with multiple holes as follows:

The algorithm \(\boldsymbol {\mathsf {SimpleDist}}(u,v,R_i)\) is modified as follows. In Line 7 we are considering u-to-v paths that cross \(\partial R_{i-1}\) , but the last \(\partial R_{i-1}\) vertex s could be on any hole of \(R_{i-1}\) . Thus, for each of the \(O(1)\) holes h we execute \(\boldsymbol {\mathsf {SimpleCentroidSearch}}(\mathrm{VD}^*_{\operatorname{in}}(u,h,R_{i-1}),v)\) and let \(d_2\) be the minimum distance found. In Line 10, there is a unique hole h of \(R_{i-1}\) for which \(v\in R_{i-1}^{h,\operatorname{out}}\) and we know that every u-to-v path must cross h. Therefore, we still only make one call to \(\boldsymbol {\mathsf {SimpleCentroidSearch}}(\mathrm{VD}^*_{\operatorname{out}}(u,h,R_{i-1}),v)\) .

Theorem 4.1 summarizes the space-time tradeoffs achievable by our simplest distance oracle.

Here, we briefly describe how to generalize the oracle described in this section for graphs embeddable onto surfaces of bounded genus. As shown by Chambers et al. [12], we can “planarize” an n-vertex graph G of genus g by repeating the following procedure g times: find a short non-contractible cycle in \(O(gn\log n)\) time using the algorithm of Erickson and Har-Peled [27] and cut along it, duplicating its vertices and edges. This algorithm thus runs in \(O(g^2 n \log n)\) time and produces an n-vertex planar graph P with exactly 2g holes that contain all the copies of the duplicated vertices. Each such hole, called a boundary cycle, is incident to \(O(\sqrt {n/g} \log g)\) vertices.

To avoid clutter, we describe our oracle for \(g=O(1)\) . We build our \(n^{4/3+2/(3\kappa)}\) -space oracle for P with \(\kappa = O(1) \ge 4\) so the space is \(O(n^{3/2})\) . Further, for each vertex \(u \in V(G)\) , for each of the \(O(1)\) boundary cycles, we build a Voronoi diagram for P with sites the vertices of the hole, and an additive weight function defined by distances from u in G, i.e., \({\rm \omega }(s)=\operatorname{dist}_G(u,s)\) . Further, for each boundary cycle C, we build an MSSP data structure for P with sources the vertices lying on C. Setting \(\kappa ^{\prime } = O(1) \ge 2,\) the space for the MSSP structures is \(O(\kappa ^{\prime } n^{1+1/\kappa ^{\prime }}) = O(n^{3/2})\) since we have \(O(1)\) boundary cycles, and the space for the Voronoi diagrams is \(O(n^{3/2})\) since there are \(O(\sqrt {n})\) vertices on boundary cycles.

Upon a query \((u,v)\) , we first compute \(\operatorname{dist}_P(u,v)\) in \(O(\log n\log \log n)\) time ( \(\kappa =O(1)\) ) using the planar distance oracle. First, note that \(\operatorname{dist}_P(u,v) \ge \operatorname{dist}_G(u,v).\) Further, observe that \(\operatorname{dist}_P(u,v) \ne \operatorname{dist}_G(u,v)\) only if some vertex on the shortest u-to-v path in G has been duplicated, and thus the path has been split. Suppose that this is the case. Let s be the last vertex on the shortest u-to-v path in G that has been duplicated. Note that s is not known at query time. By choice of s, \(\operatorname{dist}_G(u,v)=\operatorname{dist}_G(u,s)+\operatorname{dist}_P(s,v)\) . Thus, we can take care of this case by performing point location queries in each of the \(O(1)\) extra Voronoi diagrams stored for u with target v and returning the minimum distance computed by those queries. The query time is \(O(\log n\log \log n)\) since \(k^{\prime }=O(1)\) .

Thus, for n-vertex graphs embeddable to surfaces of constant genus, we obtain an oracle that occupies space \(O(n^{3/2})\) and answers queries in \(O(\log n\log \log n)\) time.

A distance query is given \(u,v\in V(G)\) . We begin by identifying the level-0 region \(R_{0}=\lbrace u\rbrace \in \mathcal {R}_{0}\) and call the function \(\boldsymbol {\mathsf {Dist}}(u,v,R_0)\) . In general, the function \(\boldsymbol {\mathsf {Dist}}(u_i,v,R_i)\) takes as arguments a region \(R_i\) , a source vertex \(u_i\) on the boundary \(\partial R_i\) , and a target vertex \(v\not\in R_i\) . It returns a value d such thatNote that \(R_{0}^{\operatorname{out}} = G\) , so the initial call to this function correctly computes \(\operatorname{dist}_G(u,v)\) . When v is “close” to \(u_i\) ( \(v\in R_i^{\operatorname{out}}\cap R_{i+1}\) ), it computes \(\operatorname{dist}_{R_i^{\operatorname{out}}}(u_i,v)\) without recursion, using part (A) of the data structure. When \(v\in R_{i+1}^{\operatorname{out}}\) , it performs point location using the function \(\boldsymbol {\mathsf {CentroidSearch}}\) , which culminates in up to two recursive calls to \(\boldsymbol {\mathsf {Dist}}\) on the level- \((i+1)\) region \(R_{i+1}\) . Thus, the correctness of \(\boldsymbol {\mathsf {Dist}}\) hinges on whether \(\boldsymbol {\mathsf {CentroidSearch}}\) correctly computes distances when \(v\in R_{i+1}^{\operatorname{out}}\) .

The procedure \(\boldsymbol {\mathsf {CentroidSearch}}\) is an adaptation of \(\boldsymbol {\mathsf {SimpleCentroidSearch}}\) . \(\boldsymbol {\mathsf {CentroidSearch}}\) is given as input \(u_i\in \partial R_i\) , \(v\in R_{i+1}^{\operatorname{out}}\) , \(\mathrm{VD}^*_{\operatorname{out}}= \mathrm{VD}^*_{\operatorname{out}}(u_i,R_{i+1})\) , and a subtree \(T^*\) of the centroid decomposition of \(\mathrm{VD}^*_{\operatorname{out}}\) . Once again, if omitted, \(T^*\) is the full centroid decomposition. It ultimately finds \(u_{i+1} \in \partial R_{i+1}\) for which \(v\in \operatorname{Vor}(u_{i+1})\) and returns

The main difficulty in implementing \(\boldsymbol {\mathsf {CentroidSearch}}\) is that we cannot afford to store MSSP structures for \(R_{i+1}^{\operatorname{out}}\) . \(\boldsymbol {\mathsf {CentroidSearch}}\) can be seen as an implementation of \(\boldsymbol {\mathsf {SimpleCentroid}}\) \(\boldsymbol {\mathsf {Search}}\) with the following modifications:

The main challenge is to efficiently implement the \(\boldsymbol {\mathsf {SitePathIndicator}}\) and \(\boldsymbol {\mathsf {ChordIndicator}}\) functions, i.e., to solve the restricted point location problem in \(R_{i+1}^{\operatorname{out}}\) , depicted in Figure 6. We will show how to solve these two point location problems in \(O(\kappa \log ^{1+o(1)} n)\) time.

We begin with the following lemma, which is used in \(\boldsymbol {\mathsf {SitePathIndicator}},\boldsymbol {\mathsf {PieceSearch}}\) , and \(\boldsymbol {\mathsf {ChordIndicator}}\) .

Let us now introduce parts (C) and (D) of our data structure. The reason for storing part (C) will become clear in subsequent sections. One of the main reasons for storing the Site Tables of part (D) is so that we can invoke Lemma 6.2, which requires that we provide \(\hat{x}_0,\hat{x}_1\) . The Side Tables of part (D) are stored so that we can handle a simple case in the \(\boldsymbol {\mathsf {ChordIndicator}}\) function where the chord does not interact at all with some specific part of the graph that contains v; they store the answer for this whole part.

The following lemma is a direct consequence of Lemma 6.2, which lets us implement the non-trivial parts of \(\boldsymbol {\mathsf {SimpleCentroidSearch}}\) in the same time bound guaranteed by Theorem 3.2.

We begin by defining the key concepts of our point location method: chords, laminar chord sets, pieces, and the occludes relation.

The orientation of chords does not always coincide with a natural orientation of paths defined by the algorithm. For example, in Figure 6, the oriented chord \(\overrightarrow{s_0s_2} = (s_0,\ldots ,y_0,y_2,\ldots ,s_2)\) is composed of three parts: a shortest \(s_0\) -to- \(y_0\) path (whose natural orientation coincides with that of \(\overrightarrow{s_0s_2}\) ), the edge \(\lbrace y_0,y_2\rbrace\) (which has no natural orientation in this context), and the shortest \(s_2\) -to- \(y_2\) path (whose natural orientation is the reverse of its orientation in \(\overrightarrow{s_0s_2}\) ). The orientation serves two purposes. In Definition 6.1 we can speak unambiguously about the parts of \(R^{\operatorname{out}}\) to the right and left of \(\overrightarrow{s_0s_2}\) . In Definition 6.2 the role of the orientation is to ensure that the partition of \(R^{\operatorname{out}}\) into pieces induced by \(\mathcal {C}\) can be represented by a tree, as we show in Lemma 6.4.

It follows from Definition 6.4 that if \(\mathcal {C}\) is laminar, the maximal chords with respect to f will intersect the boundary of f’s piece in \(\mathcal {P}(\mathcal {C})\) .

We can also speak unambiguously about a chord C occluding a vertex or edge not on C, from a certain vantage, which itself may be a face, a vertex, or a piece. Specifically, we can say that from some vantage, C occludes an interval of the boundary cycle on \(\partial R\) , say according to a clockwise traversal around the hole on \(\partial R\) in \(R^{\operatorname{out}}\) .¹⁰ This will be used in the \(\boldsymbol {\mathsf {ChordIndicator}}\) procedure of Section 6.4.2.

We next present part (E) of our data structure, which will be used to implement the functions \(\boldsymbol {\mathsf {SitePathIndicator}}\) and \(\boldsymbol {\mathsf {ChordIndicator}}\) .

We next describe how to compactly store part (E) of the data structure. Our strategy is as follows. We fix \(R_i\) and \(q\in \partial R_i\) and build a dynamic data structure for these operations relative to a dynamic subset \(\hat{\mathcal {C}} \subseteq \mathcal {C}_{q}^{R_i}\) subject to the insertion and deletion of chords in \(O(\log |\partial R_i|/\log \log |\partial R_i|)\) time. By inserting/deleting \(O(|\partial R_i|)\) chords in the correct order, we can arrange that \(\hat{\mathcal {C}} = \mathcal {C}_{q}^{R_i}[x]\) at some point in time, for every \(x\in \partial R_i\) . Using the generic persistence technique for RAM data structures (see [21]), we can answer \(\boldsymbol {\mathsf {MaximalChord}}\) queries relative to \(\mathcal {C}_{q}^{R_i}[x]\) in \(O(\log |\partial R_i|)\) time.

We will make use of a data structure of Brodal et al. [7] specified in the following lemma.

The \(\boldsymbol {\mathsf {SitePathIndicator}}\) function is relatively simple. We are given \(\mathrm{VD}^*_{\operatorname{out}}(u_i,R_{i+1})\) ; \(v\in R_{i+1}^{\operatorname{out}}\) ; a centroid \(f^* \in R_{i+1}^{\operatorname{out}}\) , f being a trichromatic face on \(y_0,y_1,y_2\) , which are, respectively, in the Voronoi cells of \(s_0,s_1,s_2\in \partial R_{i+1}\) ; and an index \(j\in \lbrace 0,1,2\rbrace\) . We would like to know if v is on the shortest \(s_j\) -to- \(y_j\) path. Recall that t is such that \(v\not\in R_t\) but \(v\in R_{t+1}\) .

Using the lookup tables in part (D) of the data structure, we find the first and last vertices (q and x) of \(\partial R_t\) on the \(s_j\) -to- \(y_j\) path. If \(q,x\) do not exist, then v is certainly not on the \(s_j\) -to- \(y_j\) path (Line 4). Using parts (A,C,D) of the data structure, we invoke \(\boldsymbol {\mathsf {SimpleCentroidSearch}}\) to find the last point z of \(\partial R_t\) on the shortest path (in G) from q to v. (See Lemma 6.3.) If z is not on the path from q to x in G (which corresponds to it not being on the path from q to x in \(T_q^{R_t}\) , stored in part (E)), then once again v is certainly not on the \(s_j\) -to- \(y_j\) path (Line 8). So we may assume that z lies on the q-to-x path. For the case where \(z=x\) , we let \(x^{\prime }\) be the last vertex of the shortest \(s_j\) -to- \(y_j\) path that is contained in the relevant subgraph \(R_t^{\operatorname{out}}\cap R_{t+1}\) . In particular, there are three cases to consider, depending on whether the destination \(y_j\) of the path is in \(R_t^{\operatorname{out}}\cap R_{t+1}\) , in \(R_{t+1}^{\operatorname{out}}\) , or in \(R_t\) . If \(y_j\in R_t^{\operatorname{out}}\cap R_{t+1}\) we let \(x^{\prime } = y_j\) ; if \(y_j\in R_{t+1}^{\operatorname{out}}\) we let \(x^{\prime }\) be the last vertex of \(\partial R_{t+1}\) encountered on the shortest \(s_j\) -to- \(y_j\) path (stored in part (D)); and if \(y_j\in R_t\) we let \(x^{\prime }=x\) . Figures 10(a) and 10(b) illustrate the first two possibilities for \(x^{\prime }\) . Now, v is on the \(s_j\) -to- \(y_j\) path iff it is on the x-to- \(x^{\prime }\) shortest path, which can be answered using part (A) of the data structure (Lines 19, 21). (Figure 10(b) illustrates one way for v to appear on the x-to- \(x^{\prime }\) path.) In the remaining case, z is on the shortest q-to-x path but is not x, meaning that the child \(z^{\prime }\) of z on \(T_q^{R_t}[x]\) is well defined. If the corresponding shortest z-to- \(z^{\prime }\) path lies in \(R_t^{\operatorname{out}}\) (i.e., it is a chord \(\overrightarrow{zz^{\prime }}\) ), then v is on the shortest \(s_j\) -to- \(y_j\) path iff it is on the shortest z-to- \(z^{\prime }\) path in \(R_t^{\operatorname{out}}\) , which, once again, can be answered with part (A) of the data structure via Lemma 6.1 (Lines 25, 27). See Figure 10(a) for an illustration of this case. Finally, if the shortest z-to- \(z^{\prime }\) path is internally disjoint from \(R_t^{\operatorname{out}}\) , then v is clearly not on the shortest \(s_j\) -to- \(y_j\) path.

The \(\boldsymbol {\mathsf {ChordIndicator}}\) function is given \(\mathrm{VD}^*_{\operatorname{out}}(u_i,R_{i+1})\) ; \(v\in R_{i+1}^{\operatorname{out}}\) ; a centroid \(f^*\) , with \(y_j,s_j\) defined as usual; and an index \(j\in \lbrace 0,1,2\rbrace\) . The goal is to report whether v lies to right of the oriented site-centroid-site chord:which is composed of the shortest \(s_j\) -to- \(y_j\) and \(s_{j-1}\) -to- \(y_{j-1}\) paths and the single edge \(\lbrace y_j,y_{j-1}\rbrace\) . Note that \(\tilde{C}\) is a simple path since the shortest \(s_j\) -to- \(y_j\) and \(s_{j-1}\) -to- \(y_{j-1}\) paths belong to different Voronoi cells. See Figure 6 for an illustration. It is guaranteed that v does not lie on \(\tilde{C}\) , as this case is already handled by the \(\boldsymbol {\mathsf {SitePathIndicator}}\) function.

Figure 11 illustrates why this point location problem is so difficult. Since we know that \(v\in R_{t+1}\) and \(v \not\in R_t\) , we can narrow our attention to \(R_t^{\operatorname{out}}\cap R_{t+1}\) . However, the projection of \(\tilde{C}\) onto \(R_t^{\operatorname{out}}\) can cross the boundary \(\partial R_t\) an arbitrary number of times. Define \(\mathcal {C}\) to be the set of oriented chords of \(R_t^{\operatorname{out}}\) obtained by projecting \(\tilde{C}\) onto \(R_t^{\operatorname{out}}\) .

Luckily \(\mathcal {C}\) has some structure. Let \((q_j,x_j)\) and \((q_{j-1},x_{j-1})\) be the first and last \(\partial R_t\) vertices on the shortest \(s_j\) -to- \(y_j\) and \(s_{j-1}\) -to- \(y_{j-1}\) paths, respectively. (One or both of these pairs may not exist.) The chords of \(\mathcal {C}\) are in one-to-one correspondence with the chords of \(\mathcal {C}_1 \cup \mathcal {C}_2 \cup \mathcal {C}_3\) , defined below but, as we will see, sometimes with their orientation reversed.

The chord-set \(\mathcal {C}\) partitions \(R_t^{\operatorname{out}}\) into a piece-set \(\mathcal {P}\) , with one such piece \(P\in \mathcal {P}\) containing v. (Remember that v is not on \(\tilde{C}\) .) We can also consider the piece-sets \(\mathcal {P}_1,\mathcal {P}_2,\mathcal {P}_3\) generated by \(\mathcal {C}_1,\mathcal {C}_2,\mathcal {C}_3\) . Let \(P_1\in \mathcal {P}_1, P_2\in \mathcal {P}_2, P_3\in \mathcal {P}_3\) be the pieces containing v. Since, ignoring orientation, \(\mathcal {C}=\mathcal {C}_1\cup \mathcal {C}_2\cup \mathcal {C}_3\) , it must be that \(P=P_1\cap P_2 \cap P_3\) . In order to determine whether v is to the right of \(\tilde{C}\) , it suffices to find some chord \(C\in \mathcal {C}\) bounding P and ask whether v is to the right of C. Note that such a chord C must also be on the boundary of one of \(P_1,P_2,\) or \(P_3\) .

The high-level strategy of \(\boldsymbol {\mathsf {ChordIndicator}}\) is as follows. First, we will find some piece \(P_1^{\prime } \in \mathcal {P}_{q_j}^{R_t}\) that is contained in \(P_1\) using the procedure \(\boldsymbol {\mathsf {PieceSearch}}\) described below. The chords of \(\mathcal {C}_1\) bounding \(P_1\) are precisely the maximal chords in \(\mathcal {C}_1\) from vantage \(P_1^{\prime }\) . Using \(\boldsymbol {\mathsf {MaximalChord}}\) (part (E)), we will find a candidate chord \(C_1\in \mathcal {C}_1\) and one edge e on the boundary cycle of \(\partial R_t\) occluded by \(C_1\) from vantage \(P_1^{\prime }\) . Turning to \(\mathcal {C}_2\) , we use \(\boldsymbol {\mathsf {AdjacentPiece}}\) to find the piece \(P_e \in \mathcal {P}_{q_{j-1}}^{R_t}\) adjacent to e. Then, using \(\boldsymbol {\mathsf {PieceSearch}}\) and \(\boldsymbol {\mathsf {MaximalChord}}\) again, we find a \(P_2^{\prime }\in \mathcal {P}_{q_{j-1}}^{R_t}\) contained in \(P_2\) and the maximal chord \(C_2\) occluding \(P_e\) from vantage \(P_2^{\prime }\) . Let \(C_3\) be the singleton chord in \(\mathcal {C}_3\) , if any. We determine an “eligible” chord \(C_\ell \in \lbrace C_1,C_2,C_3\rbrace\) , decide whether v lies to the right of \(C_{\ell }\) , and return this answer if \(\ell \in \lbrace 1,3\rbrace\) or reverse it if \(\ell =2\) . Recall that chords in \(\mathcal {C}_2\) have the opposite orientation as their counterparts in \(\mathcal {C}\) .

\(\boldsymbol {\mathsf {PieceSearch}}\) is presented in Section 6.4.1 and \(\boldsymbol {\mathsf {ChordIndicator}}\) in Section 6.4.2.

Considering functions that are \(\omega (1)\) and \(o(\log \log n)\) is of a purely theoretical nature, so in practice m and \(\kappa\) will just be set as constants. In this section we illustrate how the query time’s dependence on m can be improved from \(2^m\) to about \(2^{m/4}\) .

Observe that the space of (B) is asymptotically smaller than the space of (A). Replace (B) with (B’).

Now the space for (A) is \(\tilde{O}(n^{1+1/m+1/\kappa })=\tilde{O}(n^{1+2/m})\) and is balanced with (B’) when \(m=k\) . In the \(\boldsymbol {\mathsf {Dist}}\) function we now consider three possibilities. If \(v\in R_{i+1}\) we use part (A) to solve the problem without recursion. If \(v\not\in R_{i+1}\) but \(v\in R_{i+4}\) we proceed as usual, calling \(\boldsymbol {\mathsf {CentroidSearch}}\) \((\mathrm{VD}^*_{\operatorname{out}}(u_i,R_{i+1}),v)\) , and if \(v\not\in R_{i+4}\) we call \(\boldsymbol {\mathsf {CentroidSearch}}(\mathrm{VD}^*_{\operatorname{farout}}(u_i,R_{i+4}),v)\) . Observe that the depth of the \(\boldsymbol {\mathsf {Dist}}\) -recursion is now at most \(t/4+O(1) \lt m/4+O(1)\) , giving us a query time of \(O(m2^{m/4}\log ^2 n\log \log n)\) with space \(\tilde{O}(n^{1+2/m})\) .

The following modifications are made to parts (A)–(E) of the data structure. In all cases the space usage is unchanged, asymptotically.

At the first call to \(\boldsymbol {\mathsf {Dist}}(u,v,R_0)\) we apply Lemma 9.1 to generate the regions \(R_1,\ldots ,R_{t+1}\) and holes \(h_1,\ldots ,h_t\) that will be accessed in all recursive calls, in \(O(m)\) time.

The shortest u-to-v path in G must cross \(h_{1},\ldots ,h_{t}\) . The vertex \(u_i\) is now defined to be the last vertex in \(h_i\) on the shortest u-to-v path. Given \(u_i\) , we find \(u_{i+1}\) by solving a point location problem in \(\mathrm{VD}^*_{\operatorname{out}}(u_{i},R_{i+1},h_{i+1})\) . The \(\boldsymbol {\mathsf {SitePathIndicator}}\) and \(\boldsymbol {\mathsf {ChordIndicator}}\) routines focus on the subgraph \(R_{t}^{h_{t},\operatorname{out}}\) rather than \(R_{t}^{\operatorname{out}}\) . The general problem is no different than the single hole case, except that there may be \(O(1)\) holes of \(R_{t+1}\) lying in \(R_{t}^{h_{t},\operatorname{out}}\) , which does not cause further complications.

The existence of multiple holes does not create any serious complications in our construction algorithm.

In this subsection, we explain how to augment the MSSP data structure of Klein [11, 45] to support the lowest common ancestor query of Lemma 2.1. The MSSP data structure represents the shortest path trees rooted at the vertices S of the distinguished face f using a partially persistent [25] link-cut tree [59]. The persistent representation allows us to access the desired version of the tree with a constant-time overhead. Let \(T_s\) denote the version of the shortest path tree rooted at s. The edges of the link-cut tree \(T_s\) are partitioned into solid and dashed edges. Each maximal path of solid edges is called a solid path, which is represented by a binary search tree, where the left-right order in the search tree corresponds to the top-bottom order in the solid path (the root is top).

To locate the LCA x of u and v, we list the solid paths that intersect the path from u to the root of \(T_s\) , and those that intersect the path from v to the root of \(T_s\) . Let P be the first solid path in both lists, and let \(u^{\prime }\) and \(v^{\prime }\) be the nearest ancestors of u and v that lie on P. The LCA x is the leftmost of \(u^{\prime }\) and \(v^{\prime }\) in the search tree representing P. Once we have found x, we can retrieve the edge \(e_z\) outgoing from x and leading to the subtree containing \(z \in \lbrace u,v\rbrace\) (when \(x \ne z\) ) in additional \(O(\log n)\) time.

Generally, if we maintain the SSSP tree as the source travels around f in a dynamic data structure with update time \(t_u\) and query time \(t_q\) (for distance and LCA queries), the universal persistence method for RAM data structures (see [21]) yields an MSSP data structure with space \(O(|H|t_u)\) and query time \(O(t_q\log \log |H|)\) . Thus, to establish Lemma 2.1, it suffices to design a dynamic data structure for the following:

Here \(s^\star\) will be a fixed root vertex embedded in f with a single, weight-zero, out-edge to the current root on f. Changes to the SSSP tree are effected with \(O(|H|)\) \(\boldsymbol {\mathsf {Swap}}\) operations. Klein [45] used Sleator and Tarjan’s Link-cut trees [59], which support \(\boldsymbol {\mathsf {Swap}}\) , \(\boldsymbol {\mathsf {Dist}}\) , and \(\boldsymbol {\mathsf {LCA}}\) (among other operations) in \(O(\log |T|)\) time. We will use a souped-up version of Henzinger and King’s [38] Euler Tour trees. Let \(\mathsf {ET}(T)\) be a Euler tour of T starting and ending at \(s^\star\) . The elements of \(\mathsf {ET}(T)\) are edges, and each edge of T appears twice in \(\mathsf {ET}(T)\) , once in each direction. Each edge in T points to its two occurrences in \(\mathsf {ET}(T)\) .

Suppose \(T_{\operatorname{ante}}\) is the tree before a Swap operation and \(T_{\operatorname{post}}\) the tree afterward. It is easy to see that \(\mathsf {ET}(T_{\operatorname{post}})\) can be derived from \(\mathsf {ET}(T_{\operatorname{ante}})\) by \(O(1)\) splits and concatenations, and renaming the two elements corresponding to the swapped edge. See Figure 16. We will argue that the dynamic tree operations \(\boldsymbol {\mathsf {Swap}}\) , \(\boldsymbol {\mathsf {Dist}}\) , \(\boldsymbol {\mathsf {LCA}}\) can be implemented using the following list operations:

To implement \(\boldsymbol {\mathsf {Dist}}\) and \(\boldsymbol {\mathsf {LCA}}\) we will actually use the list data structure with different weight functions. For \(\boldsymbol {\mathsf {Dist}}\) , the weight of an edge \((x,y)\) in \(\mathsf {ET}(T)\) is \(\operatorname{dist}_T(s^\star ,y)\) . Thus, \(\boldsymbol {\mathsf {Dist}}\) is answered with a call to \(\boldsymbol {\mathsf {Weight}}\) . Each \(\boldsymbol {\mathsf {Swap}}(v,p,l)\) is effected with \(O(1)\) \(\boldsymbol {\mathsf {Split}}\) and \(\boldsymbol {\mathsf {Concatenate}}\) operations, renaming the elements of the swapped edge, as well as one \(\boldsymbol {\mathsf {Add}}(e_0,e_1,\delta)\) operation. Here \((e_0,\ldots ,e_1)\) is the sub-list corresponding to the subtree rooted at v, and \(\delta = \operatorname{dist}_{T_{\operatorname{post}}}(s^\star ,v) - \operatorname{dist}_{T_{\operatorname{ante}}}(s^\star ,v)\) is the change in distance to v, and hence all descendants of v.

To handle \(\boldsymbol {\mathsf {LCA}}\) queries, we use the list data structure where the weight of \((x,y)\) is the depth of y in T, i.e., the distance from \(s^\star\) to y under the unit length function. Once again, a \(\boldsymbol {\mathsf {Swap}}\) is implemented with \(O(1)\) \(\boldsymbol {\mathsf {Split}}\) and \(\boldsymbol {\mathsf {Concatenate}}\) operations, and one \(\boldsymbol {\mathsf {Add}}\) operation. Consider an \(\boldsymbol {\mathsf {LCA}}(u,v)\) query. Let \(e_0=(p_u,u),e_1=(p_v,v)\) be the edges into u and v from their respective parents, and suppose that \(e_0\) appears before \(e_1\) in \(\mathsf {ET}(T)\) .¹⁴ A call to \(\boldsymbol {\mathsf {RangeMin}}(e_0,e_1)\) returns the first edge \(\hat{e} = (x,y)\) in the interval \((e_0,\ldots ,e_1)\) minimizing the depth of y. It follows that y is the LCA of u and v. Furthermore, by the tiebreaking rule, if \(\hat{e} \ne e_0\) then \(\hat{e}=e_u\) is the (reversal of the) edge leading from y toward u. If \(\hat{e} = e_0\) then v is a descendant of u and \(e_u\) does not exist. To find \(e_v\) , we retrieve the edge \(\tilde{e}=(y,p_y)\) in \(\mathsf {ET}(T)\) from y to its parent and let \(\tilde{e}^{\prime }\) be its predecessor in \(\mathsf {ET}(T)\) . (Note that since \(s^\star\) has degree 1, \(\tilde{e},\tilde{e}^{\prime }\) always exist.) We call \(\boldsymbol {\mathsf {RangeMin}}(e_1,\tilde{e}^{\prime })\) . Once again, by the tiebreaking rule, it returns the first edge \(e_v = (x^{\prime },y)\) incident to y in \((e_1,\ldots ,\tilde{e}^{\prime })\) , which is the (reversal of the) first edge on the path from y to v. See Figure 17.

We have reduced our dynamic tree problem to a dynamic weighted list problem. We now explain how the dynamic list problem can be solved with balanced trees.

Fix a parameter \(\kappa \ge 1\) and let n be the total number of elements in all lists. We now argue that \(\boldsymbol {\mathsf {Split}}\) , \(\boldsymbol {\mathsf {Concatenate}}\) , and \(\boldsymbol {\mathsf {Add}}\) can be implemented in \(O(\kappa n^{1/\kappa })\) time and \(\boldsymbol {\mathsf {Weight}}\) and \(\boldsymbol {\mathsf {RangeMin}}\) take \(O(\kappa)\) time. We store the elements of each list L at the leaves of a rooted tree \(\mathcal {T}(L)\) . It satisfies the following invariants:

It is easy to show that \(\boldsymbol {\mathsf {Split}}\) and \(\boldsymbol {\mathsf {Concatenate}}\) can be implemented to satisfy Invariant II by destroying/rebuilding \(O(1)\) nodes at each level of \(\mathcal {T}\) . Each costs \(O(n^{1/\kappa })\) time to update the information covered by Invariants I and III. The total time is therefore \(O(\kappa n^{1/\kappa })\) . By Invariant I, a \(\boldsymbol {\mathsf {Weight}}(e_0)\) query takes \(O(\kappa)\) time to sum all of \(e_0\) ’s ancestors’ \(w(\cdot)\) -values. Consider an \(\boldsymbol {\mathsf {Add}}(e_0,e_1,\delta)\) or \(\boldsymbol {\mathsf {RangeMin}}(e_0,e_1)\) operation. By Invariant II, the interval \((e_0,\ldots ,e_1)\) is covered by \(O(\kappa n^{1/\kappa })\) \(\mathcal {T}\) -nodes, and furthermore, those nodes can be arranged into less than \(2\kappa\) contiguous intervals of siblings. Thus, an \(\boldsymbol {\mathsf {Add}}(e_0,e_1)\) can be implemented in \(O(\kappa n^{1/\kappa })\) time by adding \(\delta\) to the \(w(\cdot)\) -values of these nodes and rebuilding the affected range-min structures from Invariant III. A \(\boldsymbol {\mathsf {RangeMin}}\) is reduced to \(O(\kappa)\) range-minimum queries (from Invariant III) and adjusting the answers by the \(w(\cdot)\) -values of their ancestors (Invariant I). Each range-min query takes \(O(1)\) time and there are \(O(\kappa)\) ancestors with relevant \(w(\cdot)\) -values. Thus, \(\boldsymbol {\mathsf {RangeMin}}\) takes \(O(\kappa)\) time.

We have shown that the dynamic tree operations necessary for an MSSP structure can be implemented with a flexible tradeoff between update time and query time. Moreover, this lower bound meets the Pǎtraşcu-Demaine lower bound [57]. We leave it as an open problem to implement the complete set of operations supported by Link-cut trees, with update time \(O(\kappa n^{1/\kappa })\) and query time \(O(\kappa)\) .