Constant Query Time $(1 + \epsilon)$-Approximate Distance Oracle for Planar Graphs

TL;DR

This paper introduces a novel $(1+psilon)$-approximate distance oracle for planar graphs that achieves constant query time, with size and preprocessing nearly linear in the number of vertices, improving upon previous methods.

Contribution

The paper presents the first $(1+psilon)$-approximate distance oracle for planar graphs with $O(1)$ query time independent of psilon, and nearly linear size and preprocessing time.

Findings

Achieves $O(1)$ query time for approximate distances in planar graphs.

Size and preprocessing time are nearly linear in the number of vertices.

Improves upon previous $(1+psilon)$-approximate distance oracles with higher query times.

Abstract

We give a $(1+\epsilon)$-approximate distance oracle with $O(1)$ query time for an undirected planar graph $G$ with $n$ vertices and non-negative edge lengths. For $\epsilon>0$ and any two vertices $u$ and $v$ in $G$, our oracle gives a distance $\tilde{d}(u,v)$ with stretch $(1+\epsilon)$ in $O(1)$ time. The oracle has size $O(n\log n ((\log n)/\epsilon+f(\epsilon)))$ and pre-processing time $O(n\log n((\log^3 n)/\epsilon^2+f(\epsilon)))$, where $f(\epsilon)=2^{O(1/\epsilon)}$. This is the first $(1+\epsilon)$-approximate distance oracle with $O(1)$ query time independent of $\epsilon$ and the size and pre-processing time nearly linear in $n$, and improves the query time $O(1/\epsilon)$ of previous $(1+\epsilon)$-approximate distance oracle with size nearly linear in $n$.

Equations

$$d_G(u,v)\le \underset{p\in P_Q(u),q\in P_Q(v)}{\min }{d}_G(v,p)+d_G(p,q)+d_G(q,v)\le (1+ϵ)d_G(u,v).$$

$$d_G(u,p)\le \hat{d}(u,p)\le d_G(u,p)+{ϵ}_{0}d(G).$$

$$\tilde{d}(u,v)=\min \{d_X(u,v),\underset{p\in P_Q,Q\in \mathcal{B}(X)}{\min }\hat{d}(u,p)+\hat{d}(p,v)\}.$$

$$\tilde{d}(u,v)=\underset{p\in P_Q,Q\in \mathcal{B}(X_{u,v})\cup \mathcal{P}(X_{u,v})}{\min }\hat{d}(u,p)+\hat{d}(p,v)$$

$$q={\arg }_{p\in P_Q,Q\in \mathcal{B}(X_{u,v})\cup \mathcal{P}(X_{u,v})}\min \{d_G(u,p)+d_G(p,v)\}.$$

$$d_G(u,v)$$

$$\hat{d}(u,p)+\hat{d}(p,v)$$

$$\hat{d}(u,p_i)\le \hat{d}(x,p_i)+{ϵ}_{0}D\le \hat{d}(x,p_i)+{ϵ}_{0}d(G)\le \hat{d}(u,p_i)+2{ϵ}_{0}d(G)$$

$$\hat{d}(u,p_{ij})+\hat{d}(p_{ij},v)$$

$$d_G(u,v)$$

$$\left|a_i-a_{i-1}\right|$$

$$\sum _{2\le i\le l}\left|a_i-a_{i-1}\right|\le \frac{d_G(p_1,p_l)}{{ϵ}_{0}D}+2l=O(1/{ϵ}_0).$$

$$\hat{d}(u,p_y)\le d(P(u,y))+d_{Q^{\prime }}(y,p_y)\le d(P(u,y))+\frac{{ϵ}_0}{2\log n}d(G)$$

$$d_G(p_y,p)\le d(P(y,p))+d_G(y,p_y)\le d(P(y,p))+\frac{{ϵ}_0}{2\log n}d(G).$$

$$\hat{d}(u,p)$$

$$\tilde{d}(u,v)=\min \{d_X(u,v),\underset{p\in P_Q,Q\in \mathcal{B}(X)}{\min }\hat{d}(u,p)+\hat{d}(p,v)\}.$$

$$\tilde{d}(u,v)=\underset{p_{ij}^Q,Q\in \mathcal{B}(X_{u,v})\cup \mathcal{P}(X_{u,v})}{\min }\hat{d}(u,p_{ij}^Q)+\hat{d}(p_{ij}^Q,v)\le d_G(u,v)+7{ϵ}_{0}d(G).$$

$$\tilde{d}(u,v)=\underset{p_{ij}^{Q^l},1\le l\le \eta ,Q\in \mathcal{B}(X)\cup \mathcal{P}(X)}{\min }\hat{d}(u,p_{ij}^{Q_l})+\hat{d}(p_{ij}^{Q_l},v)$$

$$d_G(u,v)$$

Full text

Constant Query Time $(1+\epsilon)$-Approximate Distance Oracle for Planar Graphs111A preliminary version of the paper appeared in the Proceedings of the 26th International Symposium on Algorithms and Computation (ISAAC 2015) [8].

Qian-Ping Gu and Gengchun Xu

School of Computing Science, Simon Fraser University

Burnaby BC Canada V5A1S6

qgu@cs.sfu.ca,gxa2@sfu.ca

Abstract: We give a $(1+\epsilon)$-approximate distance oracle with $O(1)$ query time for an undirected planar graph $G$ with $n$ vertices and non-negative edge lengths. For $\epsilon>0$ and any two vertices $u$ and $v$ in $G$, our oracle gives a distance $\tilde{d}(u,v)$ with stretch $(1+\epsilon)$ in $O(1)$ time. The oracle has size $O(n\log n((\log n)/\epsilon+f(\epsilon)))$ and pre-processing time $O(n\log n((\log^{3}n)/\epsilon^{2}+f(\epsilon)))$, where $f(\epsilon)=2^{O(1/\epsilon)}$. This is the first $(1+\epsilon)$-approximate distance oracle with $O(1)$ query time independent of $\epsilon$ and the size and pre-processing time nearly linear in $n$, and improves the query time $O(1/\epsilon)$ of previous $(1+\epsilon)$-approximate distance oracle with size nearly linear in $n$.

key words: Distance oracle, planar graphs, approximate algorithms, graph decomposition

1 Introduction

Finding a distance between two vertices in a graph is a fundamental computational problem and has a wide range of applications. For this problem, there is a rich literature of algorithms. This problem can be solved by a single source shortest path algorithm such as the Dijkstra and Bellman-Ford algorithms. In many applications, it is required to compute the shortest path distance in an extreme short time. One approach to meet such a requirement is to use distance oracles.

A distance oracle is a data structure which keeps the pre-computed distance information and provides a distance between any given pair of vertices very efficiently. There are two phases in the distance oracle approach. The first phase is to compute the data structure for a given graph $G$ and the second is to provide an answer for a query on the distance between a pair of vertices in $G$. The efficiency of distance oracles is mainly measured by the time to answer a query (query time), the memory space required for the data structure (oracle size) and the time to create the data structure (pre-processing time). Typically, there is a trade-off between the query time and the oracle size. A simple approach to compute a distance oracle for graph $G$ of $n$ vertices is to solve the all pairs shortest paths problem in $G$ and keep the shortest distances in an $n\times n$ distance array. This gives an oracle with $O(1)$ query time and $O(n^{2})$ size. A large number of papers have been published for distance oracles with better measures on the product of query time and oracle size, see Sommer’s paper for a survey [16].

Planar graphs are an important model for many networks such as the road networks. Distance oracles for planar graphs have been extensively studied. Djidjev proves that for any oracle size $S\in[n,n^{2}]$, there is an exact distance oracle with query time $O(n^{2}/S)$ for weighted planar graphs [6]. There are several exact distance oracles with size $O(S)$ and more efficient query time for different ranges of $S$, for example, an oracle by Wulff-Nilsen [19] with $O(1)$ query time and $O(n^{2}(\log\log n)^{4}/\log n)$ size for weighted directed planar graphs and an oracle by Mozes and Sommer [15] with query time $O((n/\sqrt{S})\log^{2.5}n)$ and size $S\in[n\log\log n,n^{2}]$ for weighted directed planar graph. Readers may refer to Sommer’s survey paper [16] for more details.

Approximate distance oracles have been developed to achieve very fast query time and near linear size for planar graphs. For vertices $u$ and $v$ in graph $G$, let $d_{G}(u,v)$ denote the distance between $u$ and $v$. An oracle is called an $\alpha$-approximate oracle or with stretch $\alpha$ for $\alpha\geq 1$ if it provides a distance $\tilde{d}(u,v)$ with $d_{G}(u,v)\leq\tilde{d}(u,v)\leq\alpha d_{G}(u,v)$ for $u$ and $v$ in $G$. An oracle is said to have an additive stretch $\beta\geq 0$ if it provides a distance $\tilde{d}(u,v)$ with $d_{G}(u,v)\leq\tilde{d}(u,v)\leq d_{G}(u,v)+\beta$. For $\epsilon>0$, Thorup gives a $(1+\epsilon)$-approximate distance oracle with $O(1/\epsilon)$ (resp. $O(1/\epsilon+\log\log\Delta)$, where $\Delta$ is the longest finite distance between any pair of vertices in $G$) query time and $O(n\log n/\epsilon)$ (resp. $O(n(\log\Delta)\log n/\epsilon)$) size for an undirected (resp. directed) planar $G$ with non-negative edge lengths [17]. A similar result for undirected planar graphs is found independently by Klein [11]. Kawarabayashi et al. give a $(1+\epsilon)$-approximate distance oracle with $O((1/\epsilon)\log^{2}(1/\epsilon)\log\log(1/\epsilon)\log^{*}n)$ query time and $O(n\log n\log\log(1/\epsilon)\log^{*}n)$ size for undirected planar graphs with non-negative edge lengths [10]. The query times of the oracles above are fast but still at least $O(1/\epsilon)$. Recently, Wulff-Nilsen gives a $(1+\epsilon)$-approximate distance oracle with $O(n(\log\log n)^{2}/\epsilon+\log\log n/\epsilon^{2}))$ size and $O((\log\log n)^{3}/\epsilon^{2}+\log\log n\sqrt{\log\log((\log\log n)/\epsilon^{2})}/\epsilon^{2})$ query time for undirected planar graph with non-negative edge lengths [20]. This result has a better trade-off between the query time and the oracle size in the size of graph than those in [10, 11, 17].

Distance oracles with constant query time are of both theoretical and practical importance [4, 5]. Our main result is an $O(1)$ query time $(1+\epsilon)$-approximate distance oracle for undirected planar graphs with non-negative edge lengths.

Theorem 1**.**

Let $G$ be an undirected planar graph with $n$ vertices and non-negative edge lengths and let $\epsilon>0$. There is a $(1+\epsilon)$-approximate distance oracle for $G$ with $O(1)$ query time, $O(n\log n(\log n/\epsilon+f(\epsilon)))$ size and $O(n\log n(\log^{3}n/\epsilon^{2}+f(\epsilon)))$ pre-processing time, where $f(\epsilon)=2^{O(1/\epsilon)}$.

The oracle in Theorem 1 has a constant query time independent of $\epsilon$ and size nearly linear in the graph size. This improves the query time of the previous works [10, 17] that are (nearly) linear in $1/\epsilon$ for non-constant $\epsilon$. Wulff-Nilsen gives an $O(1)$ time exact distance oracle for $G$ with size $O(n^{2}(\log\log n)^{4}/\log n)$ [19]. There exists some constant $c_{0}>0$ such that for $\frac{1}{\epsilon}<c_{0}\log n$, our oracle has a smaller size.

The result in Theorem 1 can be generalized to an oracle described in the next theorem.

Theorem 2**.**

Let $G$ be an undirected planar graph with $n$ vertices and non-negative edge lengths, $\epsilon>0$ and $1\leq\eta\leq 1/\epsilon$. There is a $(1+\epsilon)$-approximate distance oracle for $G$ with $O(\eta)$ query time, $O(n\log n(\log n/\epsilon+f(\eta\epsilon)))$ size and $O(n\log n(\log^{3}n/\epsilon^{2}+f(\eta\epsilon)))$ pre-processing time, where $f(\eta\epsilon)=2^{O(1/(\eta\epsilon))}$.

Our results build on some techniques used in the previous approximate distance oracles for planar graphs. Thorup [17] gives a $(1+\epsilon)$-approximate distance oracle for planar graph $G$ with $O(1/\epsilon)$ query time. Informally, some techniques used in the oracle are as follows: Decompose $G$ into a balanced recursive subdivision; $G$ is decomposed into subgraphs of balanced sizes by shortest paths and each subgraph is decomposed recursively until every subgraph is reduced to a pre-defined size. A path $Q$ intersects a path $Q^{\prime}$ if $V(Q)\cap V(Q^{\prime})\neq\emptyset$. A set ${\mathcal{Q}}$ of paths is a path-separator for vertices $u$ and $v$ if every path between $u$ and $v$ intersects a path $Q\in{\mathcal{Q}}$. Vertices $u$ and $v$ are shortest-separated by a path $Q$ if there exist a shortest path between $u$ and $v$ that intersects $Q$. If vertices $u$ and $v$ have a path-separator ${\mathcal{Q}}$ then $u$ and $v$ is shortest-separated by some path $Q\in{\mathcal{Q}}$. For each subgraph $X$ of $G$, let ${\mathcal{P}}(X)$ be the set of shortest paths used to decompose $X$. For each path $Q\in{\mathcal{P}}(X)$ and each vertex $u$ in $X$, a set $P_{Q}(u)$ of $O(1/\epsilon)$ vertices called portals on $Q$ is selected. For vertices $u$ and $v$ shortest-separated by some path $Q$ in ${\mathcal{P}}(X)$, $\min_{p\in P_{Q}(u),q\in P_{Q}(v),Q\in{\mathcal{P}}(X)}d_{G}(u,p)+d_{G}(p,q)+d_{G}(q,v)$ is used to approximate $d_{G}(u,v)$. The oracle keeps the distances $d_{G}(u,p)$ and $d_{G}(p,v)$.

The portal set $P_{Q}(u)$ above is vertex dependent. For a path $Q$ in $G$ of length $d(Q)$, there is a set $P_{Q}$ of $O(1/\epsilon)$ portals such that for any vertices $u$ and $v$ shortest-separated by $Q$, $\min_{p\in P_{Q}}d_{G}(u,p)+d_{G}(p,v)\leq d_{G}(u,v)+\epsilon d(Q)$ [13]. Based on this and a scaling technique, Kawarabayashi et al. [10] give another $(1+\epsilon)$-approximate distance oracle: Create subgraphs of $G$ such that the vertices in each subgraph satisfy certain distance property (scaling). Each subgraph $H$ of $G$ is decomposed by shortest paths into a $\rho$-division of $H$ which consists of $O(|V(H)|/\rho)$ subgraphs of $H$, each has size $O(\rho)$. For each subgraph $X$ of $H$, let ${\mathcal{B}}(X)$ be the set of shortest paths used to separate $X$ from the rest of $H$. For each path $Q\in{\mathcal{B}}(X)$, a portal set $P_{Q}$ is selected. For vertices $u$ and $v$ shortest-separated by some path $Q\in{\mathcal{B}}(X)$, $\min_{p\in P_{Q},Q\in{\mathcal{B}}(X)}d_{H}(u,p)+d_{H}(p,v)$ is used to approximate $d_{G}(u,v)$. This oracle does not keep the distances $d_{H}(u,p)$ and $d_{H}(p,v)$ but uses the distance oracle in [15] to get the distances. By choosing an appropriate value $\rho$, the oracle has a better product of query time and oracle size than that of Thorup’s oracle.

We also use the scaling technique to create subgraphs of $G$. We decompose each subgraph $H$ of $G$ into a balanced recursive subdivision as in Thorup’s oracle. For each subgraph $X$ of $H$ and each shortest path $Q$ used to decompose $X$, we choose one set $P_{Q}$ of $O(1/\epsilon)$ portals on $Q$ for all vertices in $X$. A new ingredient in our oracle is to use a more time efficient data structure to approximate $d_{G}(u,v)$ instead of $\min_{p\in P_{Q},Q\in{\mathcal{P}}(X)}d_{H}(u,p)+d_{H}(p,v)$. Using an approach in [18], we show that the vertices in $V(X)$ can be partitioned into $s=f(\epsilon)$ classes $A_{1},...,A_{s}$ such that for every two classes $A_{i}$ and $A_{j}$, there is a key portal $p_{ij}\in P_{Q}$ and for any $u\in A_{i}$ and $v\in A_{j}$, if $u$ and $v$ are shortest-separated by $Q$ then $d_{H}(u,p_{ij})+d_{H}(p_{ij},v)\leq(1+\epsilon)d_{G}(u,v)$ and $d_{H}(u,p_{ij})+d_{H}(p_{ij},v)$ can be computed in $O(1)$ time. This gives a $(1+\epsilon)$-approximate distance oracle with $O(1)$ query time.

Our computational model is word RAM, which models what we can program using standard programming languages such as C/C++. In this model, a word is assumed big enough to store any vertex identifier or distance. We also assume basic operations, which include addition, subtraction, multiplication, bitwise operations (AND, OR, NEGATION) and left/right cyclic shift on a word have unit time cost.

The rest of the paper is organized as follows. In the next section, we give preliminaries of the paper and review the techniques on which our oracles build. In Section 3, we present distance oracles with additive stretch. In Section 4, we give the $(1+\epsilon)$-approximate distance oracles which use the additive stretch oracles as subroutines. The final section concludes the paper.

2 Preliminaries

An undirected graph $G$ consists of a set $V(G)$ of vertices and a set $E(G)$ of edges. For a subset $A\subseteq E(G)$, we denote by $V(A)$ the set of vertices incident to at least one edge of $A$. For $A\subseteq E(G)$ and $W\subseteq V(G)$, we denote by $G[A]$ and $G[W]$ the subgraphs of $G$ induced by $A$ and $W$, respectively. A graph $H$ is a subgraph of $G$ if $V(H)\subseteq V(G)$ and $E(H)\subseteq E(G)$.

A path between vertices $u$ and $v$ in $G$ is a sequence of edges $e_{1},..,e_{k}$, where $e_{i}=\{v_{i-1},v_{i}\}$ for $1\leq i\leq k$, $u=v_{0}$, $v=v_{k}$, and the vertices $v_{0},...,v_{k}$ are distinct. For any edge $e$, let $l(e)$ be the length of $e$. The length of path $Q=e_{1},...,e_{k}$ is $d(Q)=\sum_{1\leq i\leq k}l(e_{i})$. A path $Q$ is a shortest path between vertices $u$ and $v$ if $d(Q)$ is the minimum among those of all paths between $u$ and $v$. The distance between vertices $u$ and $v$ in $G$, denoted by $d_{G}(u,v)$, is the length of a shortest path between $u$ and $v$. For each vertex $u$ in $G$, the eccentricity of $u$ is $\lambda(u)=\max_{v\in V(G)}d_{G}(u,v)$. The radius of $G$ is $r(G)=\min_{u\in V(G)}\lambda(u)$. The diameter of $G$ is $d(G)=\max_{u\in V(G)}\lambda(u)$.

A graph is planar if it has a planar embedding (a drawing on a sphere without edge crossing). In the rest of this paper, graphs are undirected planar graphs with non-negative edge lengths unless otherwise stated.

A basic approach in this paper is to decompose graph $G$ into subgraphs by shortest paths. A set ${\mathcal{P}}$ of shortest paths in graph $G$ is a shortest path separator of $G$ if $G[V(G)\backslash W]$, $W=\cup_{Q\in{\mathcal{P}}}V(Q)$, has at least $t\geq 2$ connected nonempty subgraphs $G_{1},..,G_{t}$ of $G$. A set ${\mathcal{Q}}$ of paths separates subgraphs $G_{i}$ and $G_{j}$, $i\neq j$, if for any vertex $u$ in $G_{i}$ and any vertex $v$ in $G_{j}$, any path between $u$ and $v$ intersects a path in ${\mathcal{Q}}$. For a subgraph $G_{i}$ of $G$, a set ${\mathcal{B}}(G_{i})$ of paths is a boundary of $G_{i}$ if ${\mathcal{B}}(G_{i})$ separates $G_{i}$ and the rest of $G$ and for every path $Q\in{\mathcal{B}}(G_{i})$, there is an edge connecting $Q$ and $G_{i}$. For $\alpha>0$, a shortest path separator ${\mathcal{P}}$ of $G$ is called $\alpha$-balanced if $|V(G_{i})|\leq\alpha|V(G)|$ holds for every subgraph $G_{i}$. An $\alpha$-balanced recursive subdivision of $G$ is a structure that $G$ is decomposed into subgraphs $G_{1},..,G_{t}$ by an $\alpha$-balanced separator and for each $1\leq i\leq t$, $G_{i}$ is decomposed recursively until each subgraph is reduced to a pre-defined size. In the recursive decomposition of $G_{i}$, the subset of the shortest path separator ${\mathcal{P}}$ of $G$ that forms a boundary ${\mathcal{B}}(G_{i})$ of $G_{i}$ is included in computing a shortest path separator of $G_{i}$. Let $T_{r}$ be a shortest path spanning tree of graph $G$ rooted at a vertex $r$. Every path in $T_{r}$ from the root $r$ to any vertex is a shorest path and called a root path. We use Thorup’s method [17] to compute a $\frac{1}{2}$-balanced recursive subdivision using shortest path separators composed of root paths in $T_{r}$ (based on the result in [14], this can be done in linear time).

We now briefly describe Thorup’s method. Readers may refer to Section $2.5$ in [17] for more details. A recursive subdivision of $G$ can be viewed as a rooted tree $T_{G}$ with each vertex of $T_{G}$ (called a node, to be distinguished from a vertex of $G$) representing a subgraph of $G$ and the root node representing $G$. Each node in $T_{G}$ with node degree one is called a leaf node, otherwise an internal node. We identify subgraphs with their corresponding nodes in $T_{G}$ when convenient. The root node of $T_{G}$ has depth [math] and for any node $X$ of $T_{G}$, the depth of $X$ is the number of edges of $T_{G}$ from $X$ to the root node. The depth of $T_{G}$ is the largest depth of any node in $T_{G}$. For each node $X$ of $T_{G}$, let ${\mathcal{B}}(X)$ be the set of root paths that forms a boundary of $X$ (${\mathcal{B}}(G)=\emptyset$). Let $X\cup{\mathcal{B}}(X)$ denote the subgraph of $G$ induced by $V(X)\cup V({\mathcal{B}}(X))$. Let $X+{\mathcal{B}}(X)$ denote the graph obtained by removing some vertices from $X\cup{\mathcal{B}}(X)$ as follows: for every vertex $v$ of ${\mathcal{B}}(X)$ that has degree two in $X\cup{\mathcal{B}}(X)$, its incident edges $(u,v)$ and $(v,w)$ are replaced by edge $(u,w)$ whose length is the sum of the length of $(u,v)$ and that of $(v,w)$. For each internal node $X$, a $\frac{1}{2}$-balanced shortest path separator ${\mathcal{P}}(X)$ of root paths is used to decompose $X$ into subgraphs $X_{1},..,X_{t}$, $t\geq 2$, as follows: Let $W=V({\mathcal{P}}(X))$ and $X^{*}_{1},..,X^{*}_{t}$ be the connected components of $G[V(X+{\mathcal{B}}(X))\setminus W]$. Then $E(X_{i})=E(X)\cap E(X^{*}_{i})$, $1\leq i\leq t$. Note that ${\mathcal{P}}(X)$ separates $X_{i}$ from $X_{j}$ in $X$ and ${\mathcal{B}}(X)\cup{\mathcal{P}}(X)$ separates $X_{i}$ from $X_{j}$ in $G$ for $1\leq i,j\leq t$ and $i\neq j$. We now state some important properties of the $\frac{1}{2}$-balanced recursive subdivision in the next Lemma.

Lemma 1**.**

[17]** Given a graph $G$ and a shortest path spanning tree $T_{r}$ of $G$, a $\frac{1}{2}$-balanced recursive subdivision $T_{G}$ of $G$ can be computed in $O(n\log n)$ time such that for each internal node $X$ of $T_{G}$, $|V(X_{i})|\leq|V(X)|/2$ ($1\leq i\leq t$) and $|{\mathcal{P}}(X)|=O(1)$, and for each node $X$, $|{\mathcal{B}}(X)|=O(1)$. Moreover, for each node $X$ of $T_{G}$ and each root path $Q$ of $T_{r}$, if $Q\in{\mathcal{B}}(X)$, then $Q\in{\mathcal{P}}(X^{\prime})$ for some ancestor $X^{\prime}$ of $X$ in $T_{G}$.

The recursive subdivision of $G$ in Lemma 1 will be used in our oracles. Note that since the size of a subgraph is reduced by at least $1/2$, the depth of $T_{G}$ is bounded above by $\log n$. For every vertex $v\in V(G)$, we define the home of $v$, denoted by $X_{v}$, to be the node of $T_{G}$ of largest depth that contains $v$. For any $u,v\in V(G)$, we define $X_{u,v}$ to be the nearest common ancestor of $X_{u}$ and $X_{v}$ in $T_{G}$. Harel and Tarjan show in [9] that after a linear time preprocessing, the nearest common ancestor of any two nodes in a tree can be found in $O(1)$ time.

Let $Q$ be a shortest path in $G$ and $\epsilon>0$. Thorup shows that for every vertex $u$ in $G$, there is subset $P_{Q}(u)\subseteq V(Q)$ of $O(1/\epsilon)$ vertices such that for any vertices $u$ and $v$ shortest-separated by $Q$

[TABLE]

The vertices of $P_{Q}(u)$ are called portals on $Q$ for $u$. For every subgraph $X$ in a $\frac{1}{2}$-balanced recursive subdivision of $G$ and every shortest path $Q\in{\mathcal{B}}(X)\cup{\mathcal{P}}(X)$, by keeping the distance from each vertex $u$ in $X$ to every portal in $P_{Q}(u)$ explicitly, Thorup shows the following result.

Lemma 2**.**

[17]** For graph $G$ and $\epsilon>0$, there is a $(1+\epsilon)$-approximate distance oracle with $(1/\epsilon)$ query time, $O(n\log n/\epsilon)$ size and $O(n\log^{3}n/\epsilon^{2})$ pre-processing time. Especially for $\epsilon=1$, there is a $2$-approximate distance oracle for $G$ with $O(1)$ query time, $O(n\log n)$ size and $O(n\log^{3}n)$ pre-processing time.

Our oracles will use this oracle for $\epsilon=1$ (any constant works) to get a rough estimation of $d_{G}(u,v)$.

To reduce the query time to a constant independent of $\epsilon$, we will use a portal set $P_{Q}$ independent of vertex $u$. For vertices $u$ and $v$ shortest-separated by a path $Q$, $d_{G}(u,v)=\min_{p\in V(Q)}d_{G}(u,p)+d_{G}(p,v)$. For a $P_{Q}\subseteq V(Q)$, $\min_{p\in P_{Q}}d_{G}(u,p)+d_{G}(p,v)$ approximates $d_{G}(u,v)$. The following result will be used.

Lemma 3**.**

[13]** For a path $Q$ in $G$, $\epsilon>0$ and $D\geq d(Q)$, a set $P_{Q}$ of $O(1/\epsilon)$ vertices in $V(Q)$ can be selected in $O(|V(Q)|)$ time such that for any pair of vertices $u$ and $v$ shortest-separated by $Q$, $d_{G}(u,v)\leq\min_{p\in P_{Q}}d_{G}(u,p)+d_{G}(p,v)\leq d_{G}(u,v)+\epsilon D$.

The set $P_{Q}$ in Lemma 3 is called the $\epsilon$-portal set (with respect to $D$) and every vertex in $P_{Q}$ is called a portal. Given a path $Q$ starting from a vertex $r$, $\epsilon>0$ and $D\geq d(Q)$, $P_{Q}$ can be computed as follows: add $r$ to $P_{Q}$, traverse along $Q$ from $r$ and add a vertex $v\in V(Q)$ to $P_{Q}$ if $d_{G}(u,v)\geq\epsilon D/2$, where $u$ is the last added portal in $P_{Q}$. To apply the $\epsilon$-portal set to our oracle, we further need to guarantee $d_{G}(u,v)=\Omega(D)$ for vertices $u$ and $v$ in question. We will use the sparse neighborhood covers introduced in [1, 2, 3] of $G$ to achieve this goal.

Lemma 4**.**

[3]** For $G$ and $\gamma\geq 1$, connected subgraphs $G(\gamma,1),\dots,G(\gamma,n_{\gamma})$ of $G$ with the following properties can be computed in $O(n\log n)$ time:

For each vertex $u$ in $G$, there is at least one $G(\gamma,i)$ that contains $u$ and every $v$ with $d_{G}(u,v)\leq\gamma$. 2. 2.

Each vertex $u$ in $G$ is contained in at most 18 subgraphs. 3. 3.

Each subgraph $G(\gamma,i)$ has radius $r(G(\gamma,i))\leq 24\gamma-8$.

3 Oracle with additive stretch

We first give a distance oracle which for any vertices $u$ and $v$ in $G$, and any $\epsilon_{0}>0$, returns $\tilde{d}(u,v)$ with $d_{G}(u,v)\leq\tilde{d}(u,v)\leq d_{G}(u,v)+7\epsilon_{0}d(G)$. Based on the scaling technique in [10] and Lemma 4, this oracle will be extended to an oracle stated in Theorem 1 for $G$ in the next section.

We start with a basic data structure which keeps the following information:

• •

A $\frac{1}{2}$-balanced recursive subdivision $T_{G}$ of $G$ as in Lemma 1, each leaf node in $T_{G}$ has size $O(2^{(1/\epsilon_{0})})$.

• •

A table storing $X_{v}$ for every $v\in V(G)$.

• •

A data structure with $O(1)$ query time to find the nearest common ancestor $X_{u,v}$ of $X_{u}$ and $X_{v}$ in $T_{G}$ for any $u$ and $v$ in $G$.

• •

For each internal node $X$ of $T_{G}$, an $\epsilon_{0}$-portal set $P_{Q}$ for every shortest path $Q\in{\mathcal{P}}(X)\cup{\mathcal{B}}(X)$. For every $P_{Q}$, every $u\in V(X)$ and every portal $p\in P_{Q}$, distance $\hat{d}(u,p)$ with

[TABLE]

• •

For every leaf node $X$ and every pair of $u$ and $v$ in $X$, we keep

[TABLE]

The data structure above gives a distance oracle with $3\epsilon_{0}d(G)$ additive stretch and $O(1/\epsilon_{0})$ query time: Given vertices $u$ and $v$, if $X_{u,v}$ is a leaf node then $\tilde{d}(u,v)$ can be found in $O(1)$ time. Otherwise, $u$ and $v$ must be shortest-separated by some path in ${\mathcal{B}}(X_{u,v})\cup{\mathcal{P}}(X_{u,v})$. Let

[TABLE]

and

[TABLE]

From $\hat{d}(u,q)\leq d_{G}(u,q)+\epsilon_{0}d(G)$, $\hat{d}(q,v)\leq d_{G}(q,v)+\epsilon_{0}d(G)$ and Lemma 3,

[TABLE]

$\tilde{d}(u,v)$ can be computed in $O(1/\epsilon_{0})$ time because $|P_{Q}|=O(1/\epsilon_{0})$ and $|{\mathcal{B}}(X_{u,v})\cup{\mathcal{P}}(X_{u,v})|=O(1)$.

We first reduce the query time for internal nodes in the above oracle to a constant independent of $\epsilon_{0}$ and then analyse the preprocessing time of the distance oracle. For $z>0$, let $f(z)=2^{O(1/z)}$. Based on an approach in [18], we show that for each internal node $X$ and each path $Q\in{\mathcal{B}}(X)\cup{\mathcal{P}}(X)$, the vertices in $V(X)$ can be partitioned into $f(\epsilon_{0})$ classes such that for any two classes $A_{i}$ and $A_{j}$, there is a key portal $p_{ij}\in P_{Q}$ and for every $u\in A_{i}$ and every $v\in A_{j}$ shortest-separated by $Q$, $\hat{d}(u,p_{ij})+\hat{d}(p_{ij},v)\leq d_{G}(u,v)+7\epsilon_{0}d(G)$. By keeping the classes and key portals, the query time is reduced to $O(1)$. We first define the classes.

Definition 1**.**

Let $Q$ be a shortest path in $G$, $r(G)\leq D\leq d(G)$ and $P_{Q}=\{p_{1}...,p_{l}\}$ be an $\epsilon_{0}$-portal set (with respect to $D$) on $Q$. The vertices of $G$ are partitioned into classes based on $\hat{d}(u,p_{i}),p_{i}\in P_{Q}$ as follows. For each vertex $u$, a vector $\vec{\Gamma}_{u}=(a_{1},...,a_{l})$ is defined such that for $1\leq i\leq l$, $a_{i}=\left\lceil{\hat{d}(u,p_{i})/(\epsilon_{0}D)}\right\rceil$. Vertices $u$ and $v$ are in the same class if and only if $\vec{\Gamma}_{u}=\vec{\Gamma}_{v}$.

The following property of the classes defined above is straightforward.

Property 1**.**

Let $Q$ be a shortest path in $G$, $r(G)\leq D\leq d(G)$ and $P_{Q}$ be an $\epsilon_{0}$-portal set with respect to $D$ on $Q$. Let $A$ be any class of vertices in $G$ defined in Definition 1. For any two vertices $u,v\in A$ and any portal $p\in P_{Q}$, $\hat{d}(u,p)-\epsilon_{0}D\leq\hat{d}(v,p)\leq\hat{d}(u,p)+\epsilon_{0}D.$

We show more properties of the classes defined above in the next two lemmas.

Lemma 5**.**

Let $Q$ be a shortest path in $G$, $r(G)\leq D\leq d(G)$ and $P_{Q}$ be an $\epsilon_{0}$-portal set with respect to $D$ on $Q$. Let $A_{i}$ and $A_{j}$ be any two classes of vertices in $G$ defined in Definition 1. There is a key portal $p_{ij}\in P_{Q}$ such that for any vertices $u\in A_{i}$ and $v\in A_{j}$ shortest-separated by $Q$, $d_{G}(u,v)\leq\hat{d}(u,p_{ij})+\hat{d}(p_{ij},v)\leq d_{G}(u,v)+7\epsilon_{0}d(G)$.

Proof.

We choose arbitrarily a vertex $x\in A_{i}$ and a vertex $y\in A_{j}$. Let $p_{ij}=\arg_{p_{i}\in P_{Q}}\min\{\hat{d}(x,p_{i})+\hat{d}(p_{i},y)\}$ be the key portal. For any $u\in A_{i}$ and $v\in A_{j}$ shortest-separated by $Q$, let $q=\arg_{p_{i}\in P_{Q}}\min\{d_{G}(u,p_{i})+d_{G}(p_{i},v)\}$ and let $p=\arg_{p_{i}\in P_{Q}}\min\{\hat{d}(u,p_{i})+\hat{d}(p_{i},v)\}$. Then

[TABLE]

because $\hat{d}(u,q)\leq d_{G}(u,q)+\epsilon_{0}d(G)$, $\hat{d}(q,v)\leq d_{G}(q,v)+\epsilon_{0}d(G)$, $P_{Q}$ is an $\epsilon_{0}$-portal set and Lemma 3. From $u,x\in A_{i}$, Property 1 and $D\leq d(G)$,

[TABLE]

for every $p_{i}\in P_{Q}$. The same relations hold for $v,y$ because they are in $A_{j}$. So

[TABLE]

Therefore,

[TABLE]

This completes the proof of the lemma. $\Box$ ∎

Lemma 6**.**

The total number of classes by Definition 1 is $f(\epsilon_{0})$.

Proof.

Essentially, this result is proved by Weimann and Yuster in [18] but somehow hidden in other details. Below we give a self-contained proof of the lemma. For each vector $\vec{\Gamma}_{u}=(a_{1},..,a_{l})$, let $\vec{\Gamma}^{*}_{u}=(a_{1},(a_{2}-a_{1}),(a_{3}-a_{2}),..,(a_{l}-a_{l-1}))$. Then $\vec{\Gamma}_{u}=\vec{\Gamma}_{v}$ if and only if $\vec{\Gamma}^{*}_{u}=\vec{\Gamma}^{*}_{v}$. So we just need to prove that the total number of different $\vec{\Gamma}^{*}_{u}$ is $f(\epsilon_{0})$. From Definition 1,

[TABLE]

Since $P_{Q}$ is an $\epsilon_{0}$-portal set, $l=O(1/\epsilon_{0})$. So

[TABLE]

Therefore there are $2^{O(1/\epsilon_{0})}$ different vectors of $(a_{1},\left|{a_{2}-a_{1}}\right|,\left|{a_{3}-a_{2}}\right|,..,\left|{a_{l}-a_{l-1}}\right|)$. The $i$’th element of $(a_{1},(a_{2}-a_{1}),(a_{3}-a_{2}),..,(a_{l}-a_{l-1}))$ is either $\left|{a_{i}-a_{i-1}}\right|$ or $-\left|{a_{i}-a_{i-1}}\right|$. Therefore, there are $2^{O(1/\epsilon_{0})}$ different $\vec{\Gamma}^{*}_{u}$. $\Box$ ∎

Notice that we can assume that for each internal node $X$, the number of classes Definition 1 is at most $|V(X)|^{2}$ because otherwise, instead of partitioning the vertices into classes, we can simply use a $|V(X)|\times|V(X)|$ distance array to keep the shortest distance between every pair of vertices in $X$.

Now we are ready to show a data structure ${\mathop{\rm DS}}_{0}$ for our oracle with $7\epsilon_{0}d(G)$ additive stretch. ${\mathop{\rm DS}}_{0}$ contains the basic data structure given above and the following additional information:

• •

For each internal node $X$ of $T_{G}$ and each shortest path $Q\in{\mathcal{B}}(X)\cup{\mathcal{P}}(X)$, let $A_{1}^{Q},...,A_{s}^{Q}$ be the classes of vertices in $V(X)$ defined in Definition 1. For each vertex $u\in V(X)$, we give an index $I^{Q}_{X}(u)$ with $I^{Q}_{X}(u)=i$ if $u\in A^{Q}_{i}$; and an $s\times s$ array $C_{Q}$ with $C_{Q}[i,j]$ containing the key portal $p^{Q}_{ij}$ for classes $A^{Q}_{i}$ and $A^{Q}_{j}$.

We now describe how to compute the distances $\hat{d}(d,p)$ for internal nodes as defined in the basic data structure. The method is essentially the same as in the fast construction in [17], but simpler as the portal sets we use are not vertex dependent. We use Lemma 1 to get the recursive subdivision $T_{G}$ of $G$. Let $T_{r}$ be the shortest path spanning tree of $G$ as defined in Section $2$ and let $D$ be the largest length of any root path of $T_{r}$. By a depth first search of $T_{r}$ from $r$, we compute an $\epsilon_{0}$-portal set $P_{Q}$ (with respect to $D$) and an auxiliary $(\epsilon_{0}/\log n)$-portal set $\Gamma_{Q}$ (with respect to $D$) for every $Q\in{\mathcal{P}}(X)\cup{\mathcal{B}}(X)$, $X\in V(T_{G})$. We compute the distances $\hat{d}(u,p)$ for every internal node $X$ in a top-down traversal on $T_{G}$ from root $G$. We use Dijkstra’s algorithm to compute $\hat{d}(u,p)$ for every $u$ in $X$ and every $p\in P_{Q}\cup\Gamma_{Q}$, $Q\in{\mathcal{P}}(X)$. Let $X\star{\mathcal{B}}(X)$ denote the graph obtained from adding to $X\cup{\mathcal{B}}(X)$ the edges $\{u,p^{\prime}\}$ with length $\hat{d}(u,p^{\prime})$ for every $u$ in $X$ and every $p^{\prime}\in P_{Q^{\prime}}\cup\Gamma_{Q^{\prime}}$, where $Q^{\prime}\in{\mathcal{B}}(X)$ and $Q^{\prime}\in{\mathcal{P}}(X^{\prime})$ for some ancestor $X^{\prime}$ of $X$, and then removing degree two vertices of ${\mathcal{B}}(X)$ as what we do for $X+{\mathcal{B}}(X)$. For the root node, the computation is on $G$. For an internal node $X\neq G$, the computation is on $X\star{\mathcal{B}}(X)$. Note that $X\star{\mathcal{B}}(X)$ may not be planar and since $|{\mathcal{B}}(X)|=O(1)$, $|V(X\star{\mathcal{B}}(X))|$ is linear in the number of edges of $G$ incident to vertices of $X$ plus the number of portals in each path. Notice that $Q^{\prime}$ is in ${\mathcal{P}}(X^{\prime})$ for some internal node $X^{\prime}$ which is an ancestor of $X$ in $T_{G}$. So the distances $\hat{d}(u,p^{\prime})$ have been computed when we construct $X\star{\mathcal{B}}(X)$. Note that for some vertex $u$ and portal $p$, $\hat{d}(u,p)$ may be computed multiple times. But the value of $\hat{d}(u,p)$ does not change: let $H_{i},1\leq i$, be the graph on which $\hat{d}(u,p)$ is computed for the $i$th time; $\hat{d}(u,p)$ does not increase because the edge $\{u,p\}$ is contained in $H_{i}$ for $i\geq 2$; and $\hat{d}(u,p)$ does not decrease because $H_{i+1}$ is a subgraph of $H_{i}$ for $i\geq 2$. For $X$ with $|V(X)|\geq\log n/\epsilon_{0}$, we run Dijkstra’s algorithm using every $p\in P_{Q}\cup\Gamma_{Q}$ as the source. For $X$ with $|V(X)|<\log n/\epsilon_{0}$, we run Dijkstra’s algorithm using every $u$ in $X$ as the source. After the distances $\hat{d}(u,p)$, $p\in P_{Q}\cup\Gamma_{Q}$, for all internal nodes have been computed, we only keep the distances $\hat{d}(u,p)$ to the portals $p\in P_{Q}$ for every internal node.

In the next lemma, we show that the distances $\hat{d}(u,p)$ computed above meet the requirement of ${\mathop{\rm DS}}_{0}$.

Lemma 7**.**

For every internal node $X$ of $T_{G}$, every vertex $u$ in $X$ and every portal $p\in P_{Q}\cup\Gamma_{Q}$, $Q\in{\mathcal{P}}(X)$, $\hat{d}(u,p)\leq d_{G}(u,p)+\epsilon_{0}d(G)$.

Proof.

For every internal node $X$ of depth $k$ in $T_{G}$, every vertex $u$ in $X$ and every portal $p\in P_{Q}\cup\Gamma_{Q},Q\in{\mathcal{P}}(X)$, we prove by induction that $\hat{d}(u,p)\leq d_{G}(u,p)+\frac{k\epsilon_{0}}{\log n}d(G)$. For the root node (of depth 0), $\hat{d}(u,p)=d_{G}(u,p)$ because the distances are computed on $G$. Assume that for every internal node of depth at most $k-1\geq 0$, $\hat{d}(u,p)\leq d_{G}(u,p)+\frac{(k-1)\epsilon_{0}}{\log n}d(G)$. Let $X$ be a node of depth $k$. For $u$ in $X$ and $p\in P_{Q}\cup\Gamma_{Q}$, $Q\in{\mathcal{P}}(X)$, let $P(u,p)$ be a shortest path between $u$ and $p$. If $P(u,p)$ contains only edges in $X$ then $\hat{d}(u,p)=d_{G}(u,p)$ and the statement is proved. Otherwise, $P(u,p)$ can be partitioned into two subpaths $P(u,y)$ and $P(y,p)$, where every vertex of $P(u,y)$ except $y$ is in $X$ and $y$ is a vertex of a path $Q^{\prime}\in{\mathcal{B}}(X)$. Note that $y$ is incident to some vertex of $X$ so $y$ appears in $X\star{\mathcal{B}}(X)$. From the way $\Gamma_{Q^{\prime}}$ is computed and the fact that $D\leq d(G)$, where $D$ is used for computing $\Gamma_{Q^{\prime}}$, there is a portal $p_{y}\in\Gamma_{Q^{\prime}}$ such that $d_{Q^{\prime}}(y,p_{y})=d_{G}(y,p_{y})\leq\frac{\epsilon_{0}}{2\log n}d(G)$. Let $X^{\prime}$ be an ancestor of $X$ such that $Q^{\prime}\in{\mathcal{P}}(X^{\prime})$. Note that $\hat{d}(u,p_{y})$ is computed in $X^{\prime}\star{\mathcal{B}}(X^{\prime})$ and that $y$, $p_{y}$ and $X$ (and therefore $P(u,y)$) are all contained in $X^{\prime}\star{\mathcal{B}}(X^{\prime})$. Therefore,

[TABLE]

and

[TABLE]

The distance $\hat{d}(p_{y},p)$ has been computed in a node $X^{\prime}$ which is an ancestor of $X$ and has depth at most $k-1$. So $\hat{d}(p_{y},p)\leq d_{G}(p_{y},p)+\frac{(k-1)\epsilon_{0}}{\log n}d(G)$. Because edges $\{u,p_{y}\}$ and $\{p_{y},p\}$ with lengths $\hat{d}(u,p_{y})$ and $\hat{d}(p_{y},p)$ are contained in the graph $X\star{\mathcal{B}}(X)$,

[TABLE]

Since each node in $T_{G}$ has depth at most $\log n$, $\hat{d}(u,p)\leq\epsilon_{0}d(G)$. $\Box$ ∎

The next three lemmas give the pre-procesing time, space requirement and query time for data structure ${\mathop{\rm DS}}_{0}$.

Lemma 8**.**

For graph $G$ and $\epsilon_{0}>0$, data structure ${\mathop{\rm DS}}_{0}$ can be computed in $O(n(\log^{3}n/\epsilon_{0}^{2}+f(\epsilon_{0})))$ time.

Proof.

Let $T_{G}$ be the recursive subdivision of $G$ and $b=2^{(1/\epsilon_{0})}$. It takes $O(n\log n)$ time to compute $T_{G}$ (Lemma 1). It takes $O(n)$ time to compute the data structure that can answer the least common ancestor of any two nodes in $T_{G}$ in $O(1)$ time [9], $O(n\log n)$ time to compute $X_{v}$ for every $v\in V(G)$, and $O(n)$ time to compute $P_{Q}\cup\Gamma_{Q}$ for every path $Q\in{\mathcal{B}}(X)\cup{\mathcal{P}}(X)$, $X\in V(T_{G})$.

For every node $X$, let $M(X)$ be the number of edges in $G$ incident to vertices in $X$. Then $\sum_{X\in T_{G}}M(X)=O(n\log n)$. For every path $Q$, $|P_{Q}\cup\Gamma_{Q}|=O(\log n/\epsilon_{0})$ and for every node $X$ in $T_{G}$, $|{\mathcal{B}}(X)\cup{\mathcal{P}}(X)|=O(1)$. From this, for each internal node $X$, $X\star{\mathcal{B}}(X)$ has $O(M(X)+\log n/\epsilon_{0})$ vertices and $O(M(X)+\log n/\epsilon_{0})$ edges. Dijkstra’s algorithm is executed $\min\{M(X),\log n/\epsilon_{0}\}$ times for each node $X$. It takes $O(M(X)(\log n/\epsilon_{0})^{2})$ time to compute all $\hat{d}(u,p)$ for node $X$. Since the sum of $M(X)$ for all nodes $X$ of the same depth is $O(n)$, it takes $O(n(\log n/\epsilon_{0})^{2})$ time for all internal nodes of the same depth. Since $T_{G}$ has depth $O(\log n)$, it takes $O(n\log^{3}n/\epsilon_{0}^{2})$ time to compute all distances $\hat{d}(u,p)$ for all internal nodes.

To find $\tilde{d}(u,v)$ for a leaf node $X$, we first use Dijkstra’s algorithm to compute $d_{X}(u,v)$, taking every vertex of $X$ as the source. This takes $O(b^{2}\log b)=O(b^{2}/\epsilon_{0})$ time for one leaf node since $|V(X)|=O(b)$ and $O(nb/\epsilon_{0})$ time for all leaf nodes since the sum of $|V(X)|$ for all leaf nodes $X$ is $O(n)$. Then we compute

[TABLE]

From $|P_{Q}|=O(1/\epsilon_{0})$ for $Q\in{\mathcal{B}}(X)$ and $|{\mathcal{B}}(X)|=O(1)$, this takes $O(b^{2}/\epsilon_{0})$ time for one leaf node and $O(nb/\epsilon_{0})$ time for all leaf nodes. The total time to compute $\tilde{d}(u,v)$ for all leaf nodes is $O(nb/\epsilon_{0}))=O(nf(\epsilon_{0}))$.

The value $D$ for computing the classes can be found in $O(n)$ time. Since there are $O(n)$ internal nodes, by Lemma 6, it takes $O(nf(\epsilon_{0})(1/\epsilon_{0}))=O(nf(\epsilon_{0}))$ time to compute all classes and key portals. Therefore, ${\mathop{\rm DS}}_{0}$ can be computed in $O(n(\log^{3}n/\epsilon_{0}^{2}+f(\epsilon_{0})))$ time. $\Box$ ∎

Lemma 9**.**

For graph $G$ and $\epsilon_{0}>0$, the space requirement for data structure ${\mathop{\rm DS}}_{0}$ is $O(n(\log n/\epsilon_{0}+f(\epsilon_{0})))$.

Proof.

Let $T_{G}$ be the recursive subdivision of $G$ in ${\mathop{\rm DS}}_{0}$ and $b=2^{(1/\epsilon_{0})}$. Each leaf node $X$ has $O(b)$ vertices and requires $O(b^{2})$ space to keep the distances $\tilde{d}(u,v)$ for $u,v$ in the node. From this and the sum of $|V(X)|$ for all leaf nodes is $O(n)$, the space for all leaf nodes is $O(nb)=O(nf(\epsilon_{0}))$. By Lemma 1, the sum of $|V(X)|$ for all nodes $X$ in $T_{G}$ is $O(n\log n)$. From $|{\mathcal{B}}(X)\cup{\mathcal{P}}(X)|=O(1)$ for every $X$ and $|P_{Q}|=O(1/\epsilon_{0})$ for each $Q\in{\mathcal{B}}(X)\cup{\mathcal{P}}(X)$, the total space for keeping the distances $\hat{d}(u,v)$ between vertices and portals is $O(n\log n/\epsilon_{0})$. By Lemma 6, the space for the classes $A^{Q}_{1},..,A^{Q}_{s}$ in each internal node $X$ is $f(\epsilon_{0})$ for every $Q\in{\mathcal{B}}(X)\cup{\mathcal{P}}(X)$. Since there are $O(n)$ internal nodes, the total space for the classes in all nodes is $O(nf(\epsilon_{0}))=O(nf(\epsilon_{0}))$.

Therefore the space requirement for the oracle is $O(n(\log n/\epsilon_{0}+f(\epsilon_{0})))$. $\Box$ ∎

Lemma 10**.**

For graph $G$ and $\epsilon_{0}>0$, $\tilde{d}(u,v)$ with $d_{G}(u,v)\leq\tilde{d}(u,v)\leq d_{G}(u,v)+7\epsilon_{0}d(G)$ can be computed in $O(1)$ time for any $u$ and $v$ in $G$ using data structure ${\mathop{\rm DS}}_{0}$.

Proof.

Let $T_{G}$ be the recursive subdivision of $G$ in ${\mathop{\rm DS}}_{0}$. $X_{u}$, $X_{v}$ and $X_{u,v}$ can be found in $O(1)$ time. If $X_{u,v}$ is a leaf node then $\tilde{d}(u,v)$ can be found in $O(1)$ time. Otherwise, for each path $Q\in{\mathcal{B}}(X_{u,v})\cup{\mathcal{P}}(X_{u,v})$, assume that $u\in A^{Q}_{i}$ and $v\in A^{Q}_{j}$, and let $p^{Q}_{ij}$ be the key portal for $A^{Q}_{i}$ and $A^{Q}_{j}$. By Lemma 5,

[TABLE]

Since $|{\mathcal{B}}(X)\cup{\mathcal{P}}(X)|=O(1)$ and the key portal $p^{Q}_{ij}$ can be found in $O(1)$ time for each path $Q\in{\mathcal{B}}(X)\cup{\mathcal{P}}(X)$, $\tilde{d}(u,v)$ can be computed in $O(1)$ time. $\Box$ ∎

From Lemmas 8, 9 and 10, we have the following result.

Theorem 3**.**

For graph $G$ and $\epsilon_{0}>0$, there is an oracle which gives a distance $\tilde{d}(u,v)$ with $d_{G}(u,v)\leq\tilde{d}(u,v)\leq d_{G}(u,v)+7\epsilon_{0}d(G)$ for any vertices $u$ and $v$ in $G$ with $O(1)$ query time, $O(n(\log n/\epsilon_{0}+f(\epsilon_{0})))$ size and $O(n(\log^{3}n/\epsilon_{0}^{2}+f(\epsilon_{0})))$ pre-processing time.

We can make the oracle in Theorem 3 a more generalized one: For integer $\eta$ satisfying $1\leq\eta\leq 1/\epsilon_{0}$, we partition each path $Q\in{\mathcal{B}}(X)\cup{\mathcal{P}}(X)$ into $\eta$ segments $Q_{1},..,Q_{\eta}$, compute the classes $A^{Q_{l}}_{1},..,A^{Q_{l}}_{s}$ of vertices in $V(X)$ for each segment $Q_{l}$, $1\leq l\leq\eta$, and key portal $p^{Q_{l}}_{ij}$, and use

[TABLE]

to approximate $d_{G}(u,v)$. By this generalization, we get the following result.

Theorem 4**.**

For graph $G$, $\epsilon_{0}>0$ and $1\leq\eta\leq 1/\epsilon_{0}$, there is an oracle which gives a distance $\tilde{d}(u,v)$ with $d_{G}(u,v)\leq\tilde{d}(u,v)\leq d_{G}(u,v)+7\epsilon_{0}d(G)$ for any vertices $u$ and $v$ in $G$ with $O(\eta)$ query time, $O(n(\log n/\epsilon_{0}+f(\eta\epsilon_{0})))$ size and $O(n(\log^{3}n/\epsilon_{0}^{2}+f(\eta\epsilon_{0})))$ pre-processing time.

4 Oracle with $(1+\epsilon)$ stretch

For $\epsilon>0$, by choosing an $\epsilon_{0}=\frac{\epsilon}{7c}$ where $c>0$ is a constant, the oracle in Theorem 3 gives a $(1+\epsilon)$-approximate distance oracle for graph $G$ with $d_{G}(u,v)\geq d(G)/c$ for every $u$ and $v$ in $G$. For graph $G$ with $d_{G}(u,v)$ much smaller than $d(G)$ for some $u$ and $v$, we use a scaling approach as described in [10] to get a $(1+\epsilon)$-approximate distance oracle. The idea is to compute a set of oracles as described in Theorem 3, each for a computed subgraph $H$ of $G$. Given $u$ and $v$, we can find in $O(1)$ time a constant number of subgraphs (and the corresponding oracles) such that the minimum value returned by these oracles is a $(1+\epsilon)$-approximation of $d_{G}(u,v)$. Therefore a $(1+\epsilon)$-approximate distance for any $u,v$ can be computed in constant time. We assume $\epsilon>5/n$, otherwise a naive exact distance oracle with $O(1)$ query time and $O(n^{2})$ space can be used to prove Theorem 1.

Let $l_{m}$ be the smallest edge length in $G$. We assume $l_{m}\geq 1$ and the case where $l_{m}<1$ can be easily solved in a similar way by normalizing the length of each edge $e$ of $G$ to $l(e)/l_{m}$. For each scale $\gamma\in\{2^{i}|0\leq i\leq\left\lceil{\log d(G)}\right\rceil\}$, we contract every edge $e=\{u,v\}$ of length $l(e)<\gamma/n^{2}$ in $G$ and then compute a sparse cover ${\mathcal{C}}_{\gamma}=\{G(\gamma,j),j=1,...,n_{\gamma}\}$ of $G$ as in Lemma 4. Each edge of $G$ appears in subgraphs $G(\gamma,j)$ for $O(\log n)$ different scales [10]. This is because every edge $e$ only appears in scales $\gamma$ satisfying $l(e)/24\leq\gamma\leq l(e)n^{2}$. The data structure ${\mathop{\rm DS}}_{1}$ for our $(1+\epsilon)$-approximate distance oracle keeps the following information:

• •

A $2$-approximate distance oracle ${\mathop{\rm DS}}_{T}$ of $G$ in Lemma 2.

• •

Subgraphs $G(\gamma,j)$ and for each subgraph $G(\gamma,j)$, an oracle ${\mathop{\rm DS}}_{0}(\gamma,j)$ in Theorem 3 with $\epsilon_{0}=\epsilon/c^{\prime}$, $c^{\prime}>0$ is a constant to be specified below.

• •

For every $v\in V(G)$ and every scale $\gamma$, the index $j$ of every subgraph $G(\gamma,j)$ that contains $v$.

Lemma 11**.**

For graph $G$ and $\epsilon>0$, $\tilde{d}(u,v)$ with $d_{G}(u,v)\leq\tilde{d}(u,v)\leq(1+\epsilon)d_{G}(u,v)$ can be computed in $O(1)$ time for any $u$ and $v$ in $G$ using data structure ${\mathop{\rm DS}}_{1}$.

Proof.

Given vertices $u$ and $v$ in $G$, oracle ${\mathop{\rm DS}}_{T}$ gives $\tilde{d}_{T}(u,v)$ with $d_{G}(u,v)\leq\tilde{d}_{T}(u,v)\leq 2d_{G}(u,v)$ in $O(1)$ time (Lemma 2). If $\tilde{d}_{T}(u,v)=0$ then [math] is returned as $d_{G}(u,v)$. Otherwise, given $\tilde{d}_{T}(u,v)$, a scale $\gamma$ with $\gamma/2<\tilde{d}_{T}(u,v)\leq\gamma$ can be found by computing the most significant bit of $\left\lceil{\tilde{d}_{T}(u,v)}\right\rceil$. In the word RAM model with unit costs for basic operations, this can be computed in $O(1)$ time using the fusion tree data structure proposed in [7]. By Lemma 4, there is a $G(\gamma,j)$ that contains $u$ and every $w$ with $d_{G}(u,w)\leq d_{G}(u,v)\leq\gamma$ and $d(G(\gamma,j))=O(\gamma)=O(d_{G}(u,v))$. Therefore there exists a constant $c_{1}>0$ ($96$ would do) such that $d(G(\gamma,j))\leq c_{1}d_{G}(u,v)$. It is easy to see that ${\mathop{\rm DS}}_{0}(\gamma,j)$ returns a minimum distance among all the oracles at this scale containing $u,v$. By oracle ${\mathop{\rm DS}}_{0}(\gamma,j)$, we get a distance $\tilde{d}_{0}(u,v)$ with $d_{G(\gamma,j)}(u,v)\leq\tilde{d}_{0}(u,v)\leq d_{G(\gamma,j)}(u,v)+7\epsilon_{0}d(G(\gamma,j))$. Since $G(\gamma,j)$ is a subgraph obtained from $G$ with every edge $e$ with $l(e)<\gamma/n^{2}$ contracted, $d_{G(\gamma,j)}(u,v)\leq d_{G}(u,v)$. Let $L$ be the largest sum of the lengths of the contracted edges in any path in $G$. Then $d_{G}(u,v)\leq d_{G(\gamma,j)}(u,v)+L$ and $L<\gamma/n\leq\frac{4}{5}\epsilon d_{G}(u,v)$, from $\gamma<2\tilde{d}_{T}(u,v)\leq 4d_{G}(u,v)$ and $\epsilon>5/n$. Let $\tilde{d}(u,v)=\tilde{d}_{0}(u,v)+\gamma/n$. Then

[TABLE]

By choosing $c^{\prime}=35c_{1}$, we have $d_{G}(u,v)\leq\tilde{d}_{G}(u,v)\leq(1+\epsilon)d_{G}(u,v)$. By Lemma 2, it takes $O(1)$ time to compute $\tilde{d}_{T}(u,v)$. From Lemma 4, there are $O(1)$ graphs $G(\gamma,j)$ containing $u$ and $v$. From this and Theorem 3, it takes $O(1)$ time to compute $\tilde{d}(u,v)$. $\Box$ ∎

Lemma 12**.**

Data structure ${\mathop{\rm DS}}_{1}$ requires $O(n\log n(\log n/\epsilon+f(\epsilon)))$ space and can be computed in $O(n\log n(\log^{3}n/\epsilon^{2}+f(\epsilon)))$ time.

Proof.

${\mathop{\rm DS}}_{T}$ requires $O(n\log n)$ space. Each ${\mathop{\rm DS}}_{0}(\gamma,j)$ requires $O(n_{\gamma j}\log n_{\gamma j}/\epsilon+n_{\gamma j}f(\epsilon))$ space, where $n_{\gamma j}=|V(G(\gamma,j))|$. Each edge $e$ of $G$ appears in $O(\log n)$ different scales $\gamma$ and in each scale $e$ appears in $O(1)$ subgraphs $G(\gamma,j)$. From this, $\sum_{\gamma,j}n_{\gamma j}=O(n\log n)$ and ${\mathop{\rm DS}}_{1}$ requires space $O(n\log n(\log n/\epsilon+f(\epsilon)))$.

$DS_{T}$ can be computed in $O(n\log^{3}n)$ time and the sparse neighborhood covers can be computed in $O(n\log^{2}n)$ time. The time for computing ${\mathop{\rm DS}}_{0}(\gamma,j)$ for each $G(\gamma,j)$ is $O(n_{\gamma j}\log^{3}n_{\gamma j}/\epsilon^{2}+f(\epsilon))$. Therefore, ${\mathop{\rm DS}}_{1}$ can be computed in $O(n\log n(\log^{3}n/\epsilon^{2}+f(\epsilon))$ time. $\Box$ ∎

From Lemmas 11 and 12, we get Theorem 1 which is restated below.

Theorem 1**.**

For $\epsilon>0$, there is a $(1+\epsilon)$-approximate distance oracle for $G$ with $O(1)$ query time, $O(n\log n(\log n/\epsilon+f(\epsilon)))$ size and $O(n\log n(\log^{3}n/\epsilon^{2}+f(\epsilon)))$ pre-processing time.

Using the oracle in Theorem 4 instead of ${\mathop{\rm DS}}_{0}$, we get Theorem 2.

5 Concluding remarks

It is open whether there is a $(1+\epsilon)$-approximate distance oracle with $O(1)$ query time and size nearly linear in $n$ for weighted directed planar graphs. For undirected planar graphs, it is interesting to reduce oracle size and pre-processing time (the function $f(\epsilon)$) for the oracles in this paper. Experimental studies for fast query time distance oracles are worth investigating.