Efficient Algorithm for Constructing Order K Voronoi Diagrams in Road Networks

Abstract

The order k Voronoi diagram (OkVD) is an effective geometric construction to partition the geographical space into a set of Voronoi regions such that all locations within a Voronoi region share the same k nearest points of interest (POIs). Despite the broad applications of OkVD in various geographical analysis, few efficient algorithms have been proposed to construct OkVD in real road networks. This study proposes a novel algorithm consisting of two stages. In the first stage, a new one-to-all k shortest path finding procedure is proposed to efficiently determine the shortest paths to k nearest POIs for each node. In the second stage, a new recursive procedure is introduced to effectively divide boundary links within different Voronoi regions using the hierarchical tessellation property of the OkVD. To demonstrate the applicability of the proposed OkVD construction algorithm, a case study of place-based accessibility evaluation is carried out. Computational experiments are also conducted on five real road networks with different sizes, and results show that the proposed OkVD algorithm performed significantly better than state-of-the-art algorithms.

1. Introduction

The Voronoi diagram (VD) is one of the fundamental geographical constructions for partitioning a geographical space through a competitive means [1,2,3,4]. Specifically, the VD partitions the geographic space into a set of Voronoi regions based on a given set of points of interest, also known as generators. Each Voronoi region contains all the locations that share the same nearest generator, allowing for space tessellation and providing an adjacency structure for topology generation [5]. In addition, a Voronoi region can be used as container for geographical entities, making it an effective indexing structure for organizing spatial data. Due to these unique characteristics, the VD has been widely used in various geographical applications, such as mobile phone data analysis [6], facility service area delimitations [7], spatial data mining [8,9], and etc.

The order k Voronoi diagram (OkVD) is a generalization of the VD that has also received significant attention in the literature [1,10,11]. Given a set of generators, the OkVD is meant to partition the geographical space into a set of order k Voronoi regions (OkVR), where all locations within an OkVR share the same k nearest generators. These generators are determined by their order of proximity to the location, i.e., the first nearest generator, the second nearest generator, and so on until the kth nearest generator. This OkVD provides an effective tool to determine k nearest generators for any location, which is a critical step for numerous spatial analysis tasks, such as spatial interpolations [12], accessibility evaluations [13], and k nearest neighbor queries [14,15,16]. Given the broad applications of the OkVD in the geographical analysis, it is therefore necessary to develop efficient algorithms for constructing OkVDs in real-world geographical spaces.

In the literature, efficient algorithms for constructing Voronoi diagrams (VDs) have been the subject of much research. Early studies focused on the construction of VDs in homogeneous and isotropic planar spaces, where the distance between any two locations is measured by Euclidean distance [3,17]. However, recognizing that movements in urban areas is generally constrained by road networks, Erwig [18] first proposed a network Voronoi diagram (NVD) model for partitioning the urban geographical space. The NVD model quantifies distances between any two locations in the road network explicitly by using shortest path algorithms to compute the network distance [19]. Building on this work, Okabe et al. [1] developed an efficient algorithm for constructing NVDs by modifying conventional shortest path algorithms. Ohsawa [20] applied the concept of Order k Voronoi region for solving the problem of k nearest neighbor queries. As an alternative approach, Ai et al. [2] proposed an NVD construction algorithm by discretizing each road link into a set of linear units of equal length and using the stream flowing approach to construct NVDs. Chen et al. [21] proposed several new NVD models for partitioning the urban geographic space constrained by multi-mode public transport networks and developed effective algorithms for constructing NVDs in public transport networks.

To the best of our knowledge, there are few algorithms in the literature have been developed to construct order k NVD (OkNVD) in real road networks, with the notable exception of Okabe et al. [1]. For convenience, this algorithm is hereafter referred to as Okabe’s algorithm. This algorithm consists of two stages. In the first stage, the k nearest generators for each node are determined by performing the one-to-all shortest path algorithm (e.g., Dijkstra’s algorithm) $\left|\mathrm{F}\right|$ times to construct completed one-to-all shortest path trees rooted at all generators, where |F| is the number of generators. The k nearest generators for each node can be determined by sorting $\left|\mathrm{F}\right|$ shortest paths from all generators to the node. In the second stage, the OkNVD is constructed by determining all nodes and links belonging to each order k network Voronoi region (OkNVR). The idea of a lower-bound envelope is introduced to divide boundary links that belongs to at least two OkNVRs. Although Okabe’s algorithm is straightforward and easy to implement, the first stage of Okabe’s algorithm tends to have computational overheads, because it calculates too many unnecessary shortest paths, given that $\left|\mathrm{F}\right|$ is generally much larger than the k value. Furthermore, no detailed procedure was provided for implementing the idea of a lower-bound envelope method in the second stage.

Along the line of previous work [1], this study proposes an effective and efficient algorithm for constructing OkNVD in road networks. The proposed algorithm also consists of two stages, which extends the previous algorithm in the following aspects.

• A new one-to-all k shortest path procedure is proposed in the first stage to efficiently determine the k nearest generators at each node. As an extension of Okabe’s algorithm, the proposed procedure simultaneously constructs |F| shortest path trees in a single path searching process, sharing the same priority queue to coordinate the construction of shortest path trees from different generators. Unlike Dijkstra’s algorithm [22], the proposed procedure closes a node after it has been selected from the priority queue k times from different generators, allowing it to exactly determine the shortest paths from the k nearest generators. This results in partial shortest path trees being constructed, improving Okabe’s algorithm. Furthermore, the proposed procedure can directly determine the order of k nearest generators according to their order of selection from the priority queue without the need for shortest path sorting at each node.
• A new recursive procedure is introduced in the second stage to effectively divide boundary links into different OkNVRs. This study rigidly proves the hierarchical tessellation property of OkNVD. Specifically, each order j NVR is covered by a set of order j + 1 NVRs, and these order j + 1 NVRs are mutually exclusive except at the boundary points (j = 0, 1, …, k − 1). Using this hierarchical tessellation property, the introduced procedure, therefore, can recursively divide every boundary link into the order first, second, …, until the kth NVRs.
• To demonstrate the applicability of the proposed OkNVD construction algorithm, a comprehensive case study of evaluating place-based accessibility is carried out in Shenzhen, a mega-city in China. Computational experiments are also conducted using five real road networks with various settings of k and $\left|\mathrm{F}\right|$ values. Results show that the proposed OkVD algorithm performed significantly better than state-of-the-art algorithms.

The remainder of this article is organized as follows. Section 2 gives the model formulation of OkNVD and proves its hierarchical tessellation property. Section 3 describes the proposed OkNVD construction algorithm. Section 4 reports the numerical example of OkNVD application in place-based accessibility, and computational experiments using five real road networks. Section 5 presents the conclusions together with recommendations for future research in the area.

2. Model Formulation of Order k Network Voronoi Diagrams

The list of notations used in this article is summarized in Abbrevations. A road network can be represented by a directed graph, $G\left(N,A\right)$, consisting of a set of nodes $N$, and a set of links $A$. Each link $a_{ij}ϵA$ has a tail node $n_iϵN$ and a head node $n_jϵN$, and a positive link cost $t_{ij}$(length or travel time). Each node $n_j$ has a set of successor nodes $SUCC\left(n_j\right)$ and a set of predecessor nodes $PRED\left(n_j\right)$. Any location $q$ in the road network can be represented as $\left(a_{ij}, {\theta }_q\right)$ using the linear reference technique [23], where ${\theta }_q\in \left[0, 1\right]$ is the relative position on the link $a_{ij}$. The values of ${\theta }_q=0$ and ${\theta }_q=1$ refer to the tail and head nodes of the link respectively. With location $\mathrm{q}$, the link $a_{ij}$can be divided into two partial links $a_{iq}$ and $a_{qj}$, and their link costs are assumed to be proportional to relative positions as:

$$t_{iq}=t_{ij}\ast {\theta }_q$$

(1)

$$t_{qj}=t_{ij}\ast \left(1-{\theta }_q\right)$$

(2)

Let $p^{oq}$ be the shortest path from origin $o$ to destination $q$. The path cost, denoted by $t^{oq}$, can be calculated by the summation of corresponding link costs along the path:

$$t^{oq}={\displaystyle \sum }_{\forall l_{ij}}{t}_{ij}{\delta }_{ij}^{oq}$$

(3)

where ${\delta }_{ij}^{oq}$ is the binary variable of link-path incidence relationship, ${\delta }_{ij}^{oq}=1$ indicates link $a_{ij}$ on the path $p^{oq}$ and otherwise ${\delta }_{ij}^{oq}=0$.

Let $F=\left\{f_1,\dots ,f_i,\dots ,f_{\left|F\right|}\right\}$ be a set of generators located in the road network, where $\left|F\right|$ is the number of generators in $F$. Generators are typically a certain type of service facility. Given any location $q$ in the network, its first outward nearest generator, denoted by $f_{out}^{q,1}\in F$, satisfies:

$$t_1^{fq}\le t_i^{fq},\forall f_i\in F-\left\{f_{out}^{q,1}\right\}$$

(4)

where $t_1^{fq}$ is the cost of the shortest path from generator $f_{out}^{q,1}$ to location $q$ and $t_i^{fq}$ is the cost of the shortest path from any other generator $f_i\ne f_{out}^{q,1}$ (i.e., $\forall f_i\in F-\left\{f_{out}^{q,1}\right\}$) to location $q$. Subsequently, its $k$th outward nearest generator, denoted by $f_{out}^{q,K}\in F$, can be identified as that satisfying:

$$t_{K-1}^{fq}\le t_K^{fq}\le t_i^{fq}, \forall f_i\in F-\left\{f_{out}^{q,1},\dots ,f_{out}^{q,K-1}\right\}$$

(5)

Then, the set of $k$ outward nearest generators can be determined and denoted by $F_{out}^{q,K}=\left\{f_{out}^{q,1},\dots ,f_{out}^{q,K}\right\}$. Therefore, the outward OkNVD (order k network Voronoi diagram), denoted by $V{D}_{out}^K$, is to partition the road network into a set of sub-networks, called outward OkNVRs (order $k$ network Voronoi regions), denoted by $\left\{\dots ,v{r}_{Out}^{K,i},\dots \right\}$, such that all locations within any $v{r}_{Out}^{K,i}$ share the same set of $k$ nearest generators, $F_{out}^{q,K}$. The outward OkNVR, $v{r}_{Out}^{K,i}$, can be expressed as

$$v{r}_{Out}^{K,i}=\left\{\forall q|\left(t_1^{fq}\le t_i^{fq},\forall f_i\in F-F_{out}^{q,1}\right)\wedge \dots \wedge \left(t_K^{fq}\le t_i^{fq},\forall f_i\in F-F_{out}^{q,K-1}\right)\right\}$$

(6)

where ∧ represents that all conditions are satisfied simultaneously.

Because the road network is directed, the inward OkNVD can also be defined by using the shortest path in a reverse direction from location $q$ to the corresponding generator. Let $F_{in}^{q,K}=\left\{f_{in}^{q,1},\dots ,f_{in}^{q,K}\right\}$ be the set of $k$ inward nearest generators. The $j$th inward nearest generator satisfies following condition:

$$t_j^{qf}\le t_i^{qf}, \forall f_i\in F-F_{in}^{q,j-1}$$

(7)

where $t_j^{qf}$ is the cost of the shortest path from location $q$ to the $j$th inward nearest generator $f_{in}^{q,j}$. Then, the inward OkNVD, denoted by $V{D}_{in}^K$, consists of a set of inward OkNVRs, $V{D}_{in}^K=\left\{\dots ,v{r}_{in}^{K,i},\dots \right\}$. Each inward OkNVR, $v{r}_{in}^{K,i}$, delimits all locations sharing the same set of $k$ inward nearest generators, $F_{in}^{q,K}$, and it can be mathematically expressed as

$$v{r}_{in}^{K,i}=\left\{\forall q|\left(t_1^{qf}\le t_i^{qf},\forall f_i\in F-F_{in}^{q,1}\right)\wedge \dots \wedge \left(t_K^{qf}\le t_i^{qf},\forall f_i\in F-F_{in}^{q,K-1}\right)\right\}$$

(8)

The outward and inward OkNVDs are applicable for different types of generators and different applications. The outward OkNVDs are commonly for emergency facilities (e.g., fire stations) and applications whose outward travel cost $t_i^{fq}$ is critical; while the inward OkNVDs are usually for service facilities (e.g., supermarkets and shopping malls) and applications whose inward travel cost $t_i^{qf}$ is critical.

Figure 1 and Figure 2 illustrate the outward and inward OkNVDs in a well-known small road network, namely the Sioux Falls network. Figure 1a,b respectively give the outward and inward OkNVDs when $k=1$, in which OkNVDs degrade to the classical outward and inward NVDs. In both two figures, generators are given in star shapes, and their Voronoi regions are shown in the same color. As can be seen, the outward NVDs are not identical to the inward counterparts, since the road network is directed. It can also be seen that both outward and inward NVDs form a tessellation on the road network with two observations: (1) All NVDs cover the whole network (i.e., collectively exhaustive); and (2) Voronoi regions are mutually exclusive except at the boundary points. This is because the Sioux Falls network (as most real road networks) is fully connected, i.e., there exists at least one path between any two locations in the road network.

Figure 2a,b respectively shows the outward and inward OkNVDs when $k=2$ in the same Sioux Falls network. In these two OkNVDs, six OkNVRs are given in different colors. Each OkNVR delimits all locations sharing the same $k$ nearest generators. For example, all locations within in $v{r}_{out}^{2,1}$ have the same first and second nearest generators, $f_1$ and $f_2$. As can be seen, the outward (or inward) order second NVDs not only form a tessellation on the whole network but also on each outward (or inward) order first NVR. Thereby, the order-second NVD together with the order first NVD form a hierarchical tessellation on the road network. This hierarchical tessellation can also be represented by the tree structure shown in Figure 3a,b, in which the Voronoi regions were kept the same color as Figure 2a,b. The original road network is represented as a single root node at level 0 of the tree. The order first NVD is to partition the original network into a set of order first NVRs, which are represented as child nodes of nodes at level 1. Each order first NVR is further divided into a set of order second NVRs representing as its child nodes, i.e., nodes at level 2.

Since both outward and inward OkNVDs have an identical tessellation property, we only present the outward case for simplicity. Given a OkNVR, $v{r}_{out}^{K,i}$, it is said to be a child region of order $k-1$ NVR, $v{r}_{out}^{K-1,i}$, if $F_{out}^{q,K}=F_{out}^{w,K-1}\cup \left\{f_{out}^{q,K}\right\}$ holds. All child NVRs of $v{r}_{out}^{K-1,i}$ form the child region set, denoted by ${\mathrm{CRS}}_{out}^{K-1,i}=\left\{\dots ,v{r}_{out}^{K,i},\dots \right\}\subset V{R}_{out}^K$. Conversely, this $v{r}_{out}^{K-1,i}$ is said to be the parent region of any$v{r}_{out}^{K,i}\in {\mathrm{CRS}}_{out}^{K-1,i}$. The tessellation property of OkNVD can be proved rigidly as below.

Proposition 1. 

If the road network is fully connected, the outward order first NVD forms a tessellation on the road network.

Proof. 

See Proposition A1 in the Appendix A. □

Proposition 2. 

If the road network is fully connected,$CR{S}_{out}^{K-1,i}$forms a tessellation on$v{r}_{out}^{K-1,i}$.

Proof. 

See Proposition A2 in the Appendix A. □

According to Propositions 1 and 2, OkNVRs are stacked under their parent NVRs (i.e., order $k-1$ NVRs, …, until the order first NVRs), forming a $k$ level hierarchical tessellation on the road network. This hierarchical tessellation property of OkNVDs can be useful for many applications to organize spatial data. Such a property is fully utilized in the next section to construct OkNVDs.

3. Proposed Algorithm for Constructing OkNVDs

This section presents the proposed algorithms for constructing outward and inward OkNVDs in the road network. We first describe the algorithm for constructing outward OkNVD, called ConstructOutwardOkNVD. As shown in Algorithm 1, this ConstructOutwardOkNVD algorithm consists of two stages. The first stage is to efficiently determine the shortest paths to $F_{out}^{j,K}$ at each node $n_j$. To this end, a new one-to-all k shortest path finding procedure, called FindKNearestPOIs, is proposed. The second stage is to construct the outward OkNVD. Each node $n_j$ only belongs to a OkNVR and can be easily determined using the calculated $F_{out}^{j,K}$. However, a link $a_{ij}$ may belong to multiple OkNVRs. In the second stage, a recursive procedure, called AddLinkToOkNVRs, is introduced to effectively divide the link into corresponding OkNVRs using the above hierarchical tessellation property. The detailed steps of FindKNearestPOIs and AddLinkToOkNVRs procedures are described in the following sections.

Algorithm 1: Detailed steps of the proposed algorithm.

Procedure: ConstructOutwardOkNVD

Inputs: Road network $G$, Generator set $F$, and k value Returns: Outward OkNVD Stage 1. K nearest generators search: 01: Call procedure FindKNearestPOIs to calculate $F_{out}^{j,K}$ for each node $n_j$. Stage 2. The OkNVD construction: 02: For each node $n_j\in N$ 03:   Retrieve the node’s $v{r}_{out}^{K,i}$ using $F_{out}^{j,K}$, and add $n_j$ into $v{r}_{out}^{K,i}$. 04: End For 05: For each link pair of $a_{ij}$ and $a_{ji}$ 06: Call procedure AddLinkToOkNVRs($a_{ij}$, $a_{ji}$) to divide the link into corresponding OkNVRs. 07: End For 06: Return OkNVD.

3.1. The FindKNearestPOIs Procedure

To calculate shortest paths from $F_{out}^{j,K}$ at each node $n_j$, a straightforward approach [1] consists of two steps. The first step is to perform the classical one-to-all Dijkstra’s algorithm by $\left|F\right|$ times to construct the completed one-to-all shortest path trees rooted at all generators. Accordingly, $\left|F\right|$ shortest paths from all generators at each node $n_j$ are calculated. The second step is to sort the calculated $\left|F\right|$ shortest paths at each node to determine $F_{out}^{j,K}$. Using the F-Heap data structure [24], Dijkstra’s algorithm runs in the worst-case complexity of $\mathrm{O}\left(\left|\mathrm{N}\right|\mathrm{Log}\left(\left|\mathrm{N}\right|\right)+\left|\mathrm{A}\right|\right)$, where $\left|\mathrm{N}\right|$ is the number of nodes and $\left|\mathrm{A}\right|$ is the number of links. Therefore, the step requires $\mathrm{O}\left(\left|\mathrm{F}\right|\left|\mathrm{N}\right|\mathrm{Log}\left(\left|\mathrm{N}\right|\right)+\left|\mathrm{F}\right|\left|\mathrm{A}\right|\right)$. Since the second step requires $\mathrm{O}(\left|\mathrm{N}\right|{\left|\mathrm{F}\right|}^2)$, this approach runs in the worst-case complexity of $\mathrm{O}(\left|\mathrm{F}\right|\left|\mathrm{N}\right|\mathrm{Log}\left(\left|\mathrm{N}\right|\right)+\left|\mathrm{F}\right|\left|\mathrm{A}\right|+\left|\mathrm{N}\right|{\left|\mathrm{F}\right|}^2)$. Such an approach is easy for implementation. However, its computational performance significantly degrades with $\left|F\right|$, i.e., the number of generators. It tends to have computational overheads by calculating too many unnecessary shortest paths, given that $\left|F\right|$ is generally much larger than the $k$ value in practice.

In this study, a new one-to-all k shortest path procedure, i.e., FindKNearestPOIs, is proposed to efficiently determine only $k$ shortest paths from $F_{out}^{j,K}$ rather than $\left|F\right|$ shortest paths from all generators. The proposed procedure modifies the Dijkstra’s algorithm in three aspects. Firstly, the proposed procedure simultaneously constructs $\left|F\right|$ shortest path trees in a single path searching process. The Dijkstra’s algorithm maintains only one label at each node. The proposed procedure, however, maintains a label list with $\left|F\right|$ size at each node to record the shortest paths from different generators. Secondly, the proposed procedure makes use of only one priority queue for constructing all $\left|F\right|$ shortest path trees. By sharing a single priority queue, shortest path trees from all generators can be coordinated during the path-searching process. Thirdly, the proposed procedure closes a node when it was selected from the priority queue by $k$ times instead of a single selection used in Dijkstra’s algorithm. After the node was closed, $k$ shortest paths from $F_{out}^{j,K}$ were exactly determined at the node according to the monotonic increasing property of the priority queue. In addition, the ascending order of shortest paths from different generators can be directly obtained according to their selection order from the priority queue. Therefore, the proposed procedure can efficiently determine $k$ shortest paths from $F_{out}^{j,K}$ without the requirement of constructing $\left|F\right|$ completed shortest path trees from all generators and sorting the shortest paths at each node.

Algorithm 2 gives the detailed steps of the proposed FindKNearestPOIs procedure. Unlike Dijkstra’s algorithm, each node $n_j$ in the proposed procedure maintains three objects, including a label set $L{S}_j$, a selected generator set $S{G}_j$ and an open status $o{s}_j$. The label set $L{S}_j$ employs an array list structure with the size of $\left|F\right|$. The ith location of the label set, denoted by $L{S}_j\left[i\right]$, records the shortest path from the ith generator $f_i$. This way efficiently retrieves the shortest path from a specific generator. Note that it is not necessary to generate $\left|F\right|$ labels at each node; and a null object is used if the shortest path from a certain generator has not been generated. The selected generator set, $S{G}_j$, employs a linked list structure for recording the order of generators whose shortest paths to node $n_j$ were selected from the priority queue. Finally, the open status $o{s}_j$ is a binary indicator, and $o{s}_j=\mathrm{true}$ indicates that $n_j$ is open.

In the initialization step, $L{S}_j$ and $S{G}_j$ of all nodes are set to be empty, and $o{s}_j$ of all nodes are set to be true. A path (or called label) from each generator $f_i$ to itself, denoted by $p^{ff}$, is created and set its path cost $t^{ff}$ as zero. An additional property, denoted by $g^{ff}$, is introduced at the label to store the generator order $i$. This created path is added into the priority queue, denoted by $SE$.

At each iteration, a path $p^{fj}$ at the top of the priority queue $SE$ is selected. Its generator order, $g^{fj}$, is then added into the selected generator set $S{G}_j$. Once the number of generators in $S{G}_j$ reached the $k$ value, the node $n_j$ is closed by setting the $o{s}_j$ attribute to be false. In this case, $k$ shortest paths from $F_{out}^{j,K}$ have been determined at node $n_j$, and thus all paths of $L{S}_j$ still in the priority queue are eliminated without considerations. Subsequently, the selected path $p^{fj}$ is extended to its successor nodes, which are not closed. Through an open successor node $n_w$, a temporal path ${\tilde{p}}^{fw}$ is created by $p^{fj}\oplus a_{jw}$, where $\oplus$ is a path concatenation operator. The newly created path ${\tilde{p}}^{fw}$ compares to the existing path $p^{fw}$ as $L{S}_w\left[{\tilde{g}}^{fw}\right]$ from the same generator. If the existing path $p^{fw}=\varnothing$ or ${\tilde{t}}^{fw}<t^{fw}$ holds, the newly created path is kept and inserted into the priority queue; and it is discarded otherwise. The procedure continues the path selection and extension process until $SE$ is empty. When the procedure terminates, it can determine the $k$ nearest generators of each node $n_j$ (i.e., $F_{out}^{j,K}$) at the selected generator set $S{G}_j$ and k shortest paths from $F_{out}^{j,K}$ of each node $n_j$ at the label set $L{S}_j$.

Algorithm 2: Detailed steps of the FindKNearestPOIs procedure.

Procedure: FindKNearestPOIs

Inputs: Road network $G$, Generator set $F$, and k value Step 1. Initialization: 01: For each node $n_j\in N$ 02:   Set label set $L{S}_j$ as an empty array list with $\left|F\right|$ size. 03:   Set selected generator set $S{G}_j≔\varnothing$, and Set open status $o{s}_j≔true$. 04: End For 05: Initialize the priority queue $SE≔\varnothing$. 06: For each generator $f_i\in F$ 07:   Create path $p^{ff}$ from $f_i$ to itself, and Set cost as $t^{ff}:=0$ and generator as $g^{ff}≔i$. 08:   Set $L{S}_i\left[g^{ff}\right]:=p^{ff}$ and add the path into $SE≔SE\cup \left\{p^{ff}\right\}$. 09: End For Step 2. Path selection: 10: If $SE=\varnothing$, Then Stop. 11: Select the path $p^{fj}$ at the top of $SE$ and remove it from $SE≔SE-\left\{p^{fj}\right\}$. 12: Add the path’s generator into $S{G}_j≔S{G}_j\cup \left\{g^{fj}\right\}$. 13: If the size of $S{G}_j$ equals to K Then 14: Set $o{s}_j≔false$. 15: For each $p^{ej}$ in $L{S}_j$ 16:  If $p^{ej}\in SE$, Then remove it from $SE≔SE-\left\{p^{ej}\right\}$. 17: End For 18: End If Step 3. Path extension: 19: For each successor node $n_w\in SUCC\left(n_j\right)$ 20: If $o{s}_w=true$ Then 21:  Create path ${\tilde{p}}^{fw}:=p^{fj}\oplus a_{jw},$ and Set ${\tilde{t}}^{fw}:=t^{fj}+t_{jw}$ and ${\tilde{g}}^{fw}≔g^{fj}.$ 22:  Retrieve existing path $p^{fw}≔L{S}_w\left[{\tilde{g}}^{fw}\right]$. 23:  If $p^{fw}=\varnothing$ or ${\tilde{t}}^{fw}<t^{fw}$ Then 24:   If $p^{fw}\in SE$, Then remove it from $SE≔SE-\left\{p^{fw}\right\}$. 25:   Set $p^{fw}≔{\tilde{p}}^{fw}$, $t^{fw}≔{\tilde{t}}^{fw}$, $g^{fw}≔{\tilde{g}}^{fw}$ and $L{S}_w\left[{\tilde{g}}^{fw}\right]≔p^{fw}$. 26:   Add $p^{fw}$ into $SE≔SE\cup \left\{p^{fw}\right\}$. 27:  End If 28:   End If 29: End For 30: Go back to Step 2.

We can prove the optimality of the proposed FindKNearestPOIs procedure as below.

Proposition 3. 

When the proposed FindKNearestPOIs procedure terminates, it can determine shortest paths from K nearest generators$F_{out}^{j,K}$for all nodes.

Proof. 

See Proposition A3 in the Appendix A. □

The worst-case complexity of the proposed FindKNearestPOIs procedure is analyzed. Using the F-Heap data structure [24], the selection of the minimum cost path from the priority queue requires $\mathrm{O}\left(\mathrm{Log}\left(\left|\mathrm{F}\right|\left|\mathrm{N}\right|\right)\right)$, and both remove and add path into the priority queue requires $\mathrm{O}\left(1\right)$, where $\left|\mathrm{F}\right|\left|\mathrm{N}\right|$ is the maximum paths in the priority queue. Since $k\left|\mathrm{N}\right|$ is the maximum number of path selection from the priority queue, the proposed procedure thus runs in the worst-case complexity of $\mathrm{O}\left(k\left|\mathrm{N}\right|\mathrm{Log}\left(\left|\mathrm{F}\right|\left|\mathrm{N}\right|\right)+k\left|\mathrm{A}\right|\right)$. This complexity is significantly better than the previous Okabe’s algorithm, i.e., $\mathrm{O}(\left|\mathrm{F}\right|\left|\mathrm{N}\right|\mathrm{Log}\left(\left|\mathrm{N}\right|\right)+\left|\mathrm{F}\right|\left|\mathrm{A}\right|+\left|\mathrm{N}\right|{\left|\mathrm{F}\right|}^2)$.

3.2. The AddLinkToOkNVRs Procedure

In Okabe’s algorithm [1], a complicated idea of a lower-bound envelope was introduced to divide boundary links which belong to at least two distinctive OkNVRs. However, no detailed procedure was given to implement such an idea.

In this study, a new recursive procedure, AddLinkToOkNVRs, is introduced to effectively divide boundary links into different OkNVRs using the hierarchical tessellation property, i.e., Propositions 1 and 2. The detailed steps of the introduced procedure is given in Algorithm 3. Figure 4 illustrates this procedure using a simple example of two directed links $a_{jw}$ and $a_{wj}$. Two end nodes, $n_j$ and $n_w$, are given in the figure with the selected generator sets, $S{G}_j=\left\{1,2,3\right\}$ and $S{G}_w=\left\{4,5,1\right\}$. Because $S{G}_j\ne S{G}_w$ holds, these two links are not in the same OkNVR, so called boundary links (their end nodes are shown in different colors). This AddLinkToOkNVRs procedure divides boundary links into a set of partial links through the hierarchical tessellation from the first level until the kth level. When dividing links at the first level, we focus on only $S{G}_j\left[1\right]$ (i.e., Generator 1) and $S{G}_w\left[1\right]$ (i.e., Generator 4) and their shortest paths, $p_1^{fj}=L{S}_j\left[S{G}_j\left[1\right]\right]$ and $p_1^{fw}=L{S}_w\left[S{G}_w\left[1\right]\right]$.

The procedure consists of three steps. The first step (i.e., Step 2.1) is to divide links $a_{jw}$ and $a_{wj}$ into four partial links. Using the equal travel times between left-bound route $p_1^{fu}=p_1^{fj}\oplus a_{ju}$ and right-bound route $p_1^{fv}:=p_1^{fw}\oplus a_{wv}$, we can determine break point ${\theta }_u$ on link $a_{jw}$ (or ${\theta }_v$ on link $a_{wj}$) as

$${\theta }_u=(f_1^{fw}-t_1^{fj}+t_{wj})/\left(t_{wj}+t_{jw}\right)$$

(9)

$${\theta }_v=1-{\theta }_u$$

(10)

Then, the path cost for $p_1^{fu}$ is calculated as $t_1^{fu}≔t_1^{fj}+t_{jw}{\theta }_u$ and its generator is set as $g_1^{fu}≔g_1^{fj}$. Similar, the path cost for $p_1^{fv}$ is determined as $t_1^{fv}≔t_1^{fw}+t_{wv}{\theta }_v$ and $g_1^{fv}≔g_1^{fw}$. On the same break point, we create two new nodes, namely a left-bound node $n_u$ and right-bound node $n_v$. Then, we divide two links $a_{jw}$ and $a_{wj}$ into four newly partial links, including two left-bound partial links, $a_{ju}$ and $a_{uj}$, and two right-bound partial links, $a_{vw}$ and $a_{wv}$. For example, partial link $a_{ju}=\left(a_{jw},0, {\theta }_u\right)$ represents part of link $a_{jw}$ from 0 to ${\theta }_u$ using the linear reference.

The second step (i.e., Step 2.2) is to determine the selected generator sets ($S{G}_u$ and $S{G}_v$) and label sets ($L{S}_u$ and $L{S}_v$) for newly created nodes $n_u$ and $n_v$. It is easy to determine $S{G}_j\left[1\right]$ (e.g., Generator 1) and $S{G}_w\left[1\right]$ (e.g., Generator 4) as the first and second generators of the left-bound node $n_u$, e.g., $S{G}_u=\left\{1,4\right\}$. A reverse order is used for the right-bound node $n_v$, i.e., $S{G}_v=\left\{4,1\right\}$. Since $L{S}_u$ and $L{S}_v$ have identical path sets, we use $LS$ to represent them, i.e., $LS\left[1\right]=p_1^{fu}$ and $LS\left[4\right]=p_1^{fv}$. Subsequently, we construct candidate paths to determine other $k-2$ nearest generators in addition to $S{G}_j\left[1\right]$ and $S{G}_w\left[1\right]$. Because candidate paths should pass through two end nodes, $n_j$ and $n_w$, we construct $p_l^{fj}\oplus a_{ju}$ and $p_l^{fv}:=p_l^{fw}\oplus a_{wv}$ for any path $p_l^{fj}$ and $p_l^{fw}$ maintained at $n_j$ and $n_w$ respectively. All constructed candidate paths are inserted into the priority queue, denoted by $CSE$. Then, the top $k-2$ paths from $CSE$ are identified and stored at $LS$, and their generators are inserted into $S{G}_u$ and $S{G}_v$, e.g., $S{G}_u=\left\{1,4,2\right\}$ and $S{G}_v=\left\{4,1,2\right\}$. After this step was performed, we divided two input links into four partial links within two NVRs, e.g., $v{r}_{out}^{1,1}$ and $v{r}_{out}^{1,2}$, at the first level.

The last step (i.e., Step 2.3) is to recursively call the AddLinkToOkNVRs procedure for the link division at the next level by using the newly created left-bound links ($a_{ju}$ and $a_{uj}$) and right-bound links ($a_{vw}$ and $a_{wv}$) as two input links respectively.

For the link division at the ith level, this procedure focuses on only Scenario 2 of $S{G}_j\left[i\right]\ne S{G}_w\left[i\right]$. This is because we have Scenario 1 of $S{G}_j\left[l\right]=S{G}_w\left[l\right]$ for $\forall l=1,\dots ,i$, in which $S{G}_j\left[l\right]$ and $L{S}_j\left[S{G}_j[l]\right]$ are kept for the setting ($S{G}_u$ and $S{G}_v$) and label sets ($L{S}_u$ and $L{S}_u$) at the ith level. The link division of the ith level has the similar three steps as that of the first level. This procedure recursively performed until Scenario 3 of $S{G}_u\left[l\right]=S{G}_v\left[l\right]$ for $\forall l=1,\dots ,k$ holds. After the procedure terminated, input links were divided into a set of partial links belonging to different OkNVRs, e.g., $v{r}_{out}^{3,1}$,…,$v{r}_{out}^{3,6}$ in the illustrative example.

Algorithm 3: Detailed steps of the AddLinkToOkNVRs procedure.

Procedure: AddLinkToOkNVRs

Inputs: Links ${\mathrm{a}}_{\mathrm{jw}}$ and ${\mathrm{a}}_{\mathrm{wj}}$ 01: Set $\mathrm{SG}:=\varnothing$ and Set $\mathrm{LS}$ as empty array lists with $\left|\mathrm{F}\right|$ size. 02: For $\mathrm{i}:=1$ to $\mathrm{k}$ 03: If ${\mathrm{SG}}_{\mathrm{j}}\left[\mathrm{i}\right]={\mathrm{SG}}_{\mathrm{w}}\left[\mathrm{i}\right]$ Then (Scenario 1) 04:   Set $\mathrm{SG}:=\mathrm{SG}\cup {\mathrm{SG}}_{\mathrm{j}}\left[\mathrm{i}\right]$ and $\mathrm{LS}\left[{\mathrm{SG}}_{\mathrm{j}}\left[\mathrm{i}\right]\right]:={\mathrm{LS}}_{\mathrm{j}}\left[{\mathrm{SG}}_{\mathrm{j}}\left[\mathrm{i}\right]\right]$. 05: Else (Scenario 2) Step 2.1. Divide two links into four partial links: 06:   Retrieve ${\mathrm{p}}_{\mathrm{i}}^{\mathrm{fj}}:={\mathrm{LS}}_{\mathrm{j}}\left[{\mathrm{SG}}_{\mathrm{j}}\left[\mathrm{i}\right]\right]$ and ${\mathrm{p}}_{\mathrm{i}}^{\mathrm{fw}}:={\mathrm{LS}}_{\mathrm{w}}\left[{\mathrm{SG}}_{\mathrm{w}}\left[\mathrm{i}\right]\right]$. 07:   Calculate ${\mathsf{\theta }}_{\mathrm{u}}:=\left({\mathrm{t}}_{\mathrm{i}}^{\mathrm{fw}}-{\mathrm{t}}_{\mathrm{i}}^{\mathrm{fj}}+{\mathrm{t}}_{\mathrm{wj}}\right)/\left({\mathrm{t}}_{\mathrm{wj}}+{\mathrm{t}}_{\mathrm{jw}}\right)$ and ${\mathsf{\theta }}_{\mathrm{v}}:=1-{\mathsf{\theta }}_{\mathrm{u}}$. 08:   Create left-bound path ${\mathrm{p}}_{\mathrm{i}}^{\mathrm{fu}}:={\mathrm{p}}_{\mathrm{i}}^{\mathrm{fj}}\oplus { \mathrm{a}}_{\mathrm{ju}}$ and Set ${\mathrm{t}}_{\mathrm{i}}^{\mathrm{fu}}≔{\mathrm{t}}_{\mathrm{i}}^{\mathrm{fj}}+{\mathrm{t}}_{\mathrm{jw}}{\mathsf{\theta }}_{\mathrm{u}}$ and ${\mathrm{g}}_{\mathrm{i}}^{\mathrm{fu}}≔{\mathrm{g}}_{\mathrm{i}}^{\mathrm{fj}}$. 09:   Create right-bound path ${\mathrm{p}}_{\mathrm{i}}^{\mathrm{fv}}:={\mathrm{p}}_{\mathrm{i}}^{\mathrm{fw}}\oplus { \mathrm{a}}_{\mathrm{wv}}$ and Set ${\mathrm{t}}_{\mathrm{i}}^{\mathrm{fv}}≔{\mathrm{t}}_{\mathrm{i}}^{\mathrm{fw}}+{\mathrm{t}}_{\mathrm{wv}}{\mathsf{\theta }}_{\mathrm{v}}$ and ${\mathrm{g}}_{\mathrm{i}}^{\mathrm{fv}}≔{\mathrm{g}}_{\mathrm{i}}^{\mathrm{fw}}$. 10:   Create left-bound node ${\mathrm{n}}_{\mathrm{u}}$ and partial links ${\mathrm{a}}_{\mathrm{ju}}:=\left({\mathrm{a}}_{\mathrm{jw}},0,{ \mathsf{\theta }}_{\mathrm{u}}\right)$ and ${\mathrm{a}}_{\mathrm{uj}}:=\left({\mathrm{a}}_{\mathrm{wj}},{ \mathsf{\theta }}_{\mathrm{v}},1\right)$. 11:   Create right-bound node ${\mathrm{n}}_{\mathrm{v}}$ and partial links ${\mathrm{a}}_{\mathrm{vw}}:=\left({\mathrm{a}}_{\mathrm{wj}},{\mathsf{\theta }}_{\mathrm{u}}, 1\right)$ and ${\mathrm{a}}_{\mathrm{wv}}:=\left({\mathrm{a}}_{\mathrm{jw}},0,{ \mathsf{\theta }}_{\mathrm{v}}\right)$. Step 2.2. Set the selected generator set and the label set for two newly created nodes: 12:   Set $\mathrm{LS}\left[{\mathrm{SG}}_{\mathrm{j}}\left[\mathrm{i}\right]\right]≔{\mathrm{p}}_{\mathrm{i}}^{\mathrm{fu}}$ and $\mathrm{LS}\left[{\mathrm{SG}}_{\mathrm{w}}\left[\mathrm{i}\right]\right]≔{\mathrm{p}}_{\mathrm{i}}^{\mathrm{fv}}$. 13:   Set ${\mathrm{SG}}_{\mathrm{u}}:=\mathrm{SG}\cup \left\{{\mathrm{SG}}_{\mathrm{j}}\left[\mathrm{i}\right]\right\}$ and ${\mathrm{SG}}_{\mathrm{v}}:=\mathrm{SG}\cup \left\{{\mathrm{SG}}_{\mathrm{w}}\left[\mathrm{i}\right]\right\}$. 14:   If $\mathrm{Size}\left({\mathrm{SG}}_{\mathrm{u}}\right)<\mathrm{k}$ Then 15:     Set ${\mathrm{SG}}_{\mathrm{u}}:={\mathrm{SG}}_{\mathrm{u}}\cup \left\{{\mathrm{SG}}_{\mathrm{w}}\left[\mathrm{i}\right]\right\}$ and ${\mathrm{SG}}_{\mathrm{v}}:={\mathrm{SG}}_{\mathrm{v}}\cup \left\{{\mathrm{SG}}_{\mathrm{j}}\left[\mathrm{i}\right]\right\}$. 16:     Set priority queue $\mathrm{CSE}:=\varnothing$. 17:     For $\mathrm{l}:=\mathrm{i}+1$ to $\mathrm{k}$ 18:    Retrieve ${\mathrm{p}}_{\mathrm{l}}^{\mathrm{fj}}:={\mathrm{LS}}_{\mathrm{j}}\left[{\mathrm{SG}}_{\mathrm{j}}\left[\mathrm{l}\right]\right]$ and ${\mathrm{p}}_{\mathrm{l}}^{\mathrm{fw}}:={\mathrm{LS}}_{\mathrm{w}}\left[{\mathrm{SG}}_{\mathrm{w}}\left[\mathrm{l}\right]\right]$. 19:    Create candidate path ${\mathrm{p}}_{\mathrm{l}}^{\mathrm{fu}}:={\mathrm{p}}_{\mathrm{l}}^{\mathrm{fj}}\oplus { \mathrm{a}}_{\mathrm{ju}}$ and Set ${\mathrm{t}}_{\mathrm{l}}^{\mathrm{fu}}≔{\mathrm{t}}_{\mathrm{l}}^{\mathrm{fj}}+{\mathrm{t}}_{\mathrm{jw}}{\mathsf{\theta }}_{\mathrm{u}}$ and ${\mathrm{g}}_{\mathrm{l}}^{\mathrm{fu}}≔{\mathrm{g}}_{\mathrm{l}}^{\mathrm{fj}}$. 20:    Create candidate path ${\mathrm{p}}_{\mathrm{l}}^{\mathrm{fv}}:={\mathrm{p}}_{\mathrm{l}}^{\mathrm{fw}}\oplus { \mathrm{a}}_{\mathrm{wv}}$ and Set ${\mathrm{t}}_{\mathrm{l}}^{\mathrm{fv}}≔{\mathrm{t}}_{\mathrm{l}}^{\mathrm{fw}}+{\mathrm{t}}_{\mathrm{wv}}{\mathsf{\theta }}_{\mathrm{v}}$ and ${\mathrm{g}}_{\mathrm{l}}^{\mathrm{fv}}≔{\mathrm{g}}_{\mathrm{l}}^{\mathrm{fw}}$. 21:    Add them into $\mathrm{CSE}≔\mathrm{CSE}\cup \left\{{\mathrm{p}}_{\mathrm{l}}^{\mathrm{fu}}\right\}\cup \left\{{\mathrm{p}}_{\mathrm{l}}^{\mathrm{fv}}\right\}$. 22:  End For 23:  For $\mathrm{m}:=\mathrm{Size}\left({\mathrm{SG}}_{\mathrm{u}}\right)$ to $\mathrm{k}$ 24:    Select the path ${\mathrm{p}}_{\mathrm{l}}^{\mathrm{fm}}$ at the top of $\mathrm{CSE}$ and remove it from $\mathrm{CSE}≔\mathrm{CSE}-\left\{{\mathrm{p}}_{\mathrm{l}}^{\mathrm{fm}}\right\}$. 25:    Set ${\mathrm{SG}}_{\mathrm{u}}≔{\mathrm{SG}}_{\mathrm{u}}\cup \left\{{\mathrm{g}}_{\mathrm{l}}^{\mathrm{fm}}\right\}$ and ${\mathrm{SG}}_{\mathrm{v}}≔{\mathrm{SG}}_{\mathrm{v}}\cup \left\{{\mathrm{g}}_{\mathrm{l}}^{\mathrm{fm}}\right\}$. 26:    Set $\mathrm{LS}\left[{\mathrm{g}}_{\mathrm{l}}^{\mathrm{fm}}\right]≔{ \mathrm{p}}_{\mathrm{l}}^{\mathrm{fm}}$. 27:  End For 28:   End If 29:   Set ${\mathrm{LS}}_{\mathrm{u}}≔\mathrm{LS}$ and ${\mathrm{LS}}_{\mathrm{v}}≔\mathrm{LS}$. Step 2.3. Recursively divide four newly created partial links: 30:   Call AddLinkToOkNVRs$\left({\mathrm{a}}_{\mathrm{ju}},{\mathrm{a}}_{\mathrm{uj}}\right)$ and AddLinkToOkNVRs$\left({\mathrm{a}}_{\mathrm{vw}},{\mathrm{a}}_{\mathrm{wv}}\right)$. 31:   Return. 32:   End If 33: End For 34: Add ${\mathrm{a}}_{\mathrm{jw}}$ and ${\mathrm{a}}_{\mathrm{wj}}$ into ${\mathrm{vr}}_{\mathrm{out}}^{\mathrm{K},\mathrm{i}}$ using ${\mathrm{SG}}_{\mathrm{j}}$ as the k nearest generators. (Scenario 3)

We can prove the optimality of the introduced AddLinkToOkNVRs procedure below.

Proposition 4. 

When the introduced AddLinkToOkNVRs procedure terminates, it can correctly divide two input links into a set of OkNVRs.

Proof. 

See Proposition A4 in Appendix A. □

The worst-case complexity of the introduced AddLinkToOkNVRs procedure is also analyzed. In the procedure, Step 2.1 runs in $\mathrm{O}\left(1\right)$; and Step 2.2 runs in $\mathrm{O}\left(k\mathrm{Log}\left(k\right)\right)$ using the F-heap data structure. Because the procedure recursively divides input links from the first level until the k level, it runs in the complexity of $\mathrm{O}\left(k^2\mathrm{Log}\left(k\right)\right)$.

3.3. Complexity Analysis of the Proposed OkNVD Construction Algorithms

With Propositions 3 and 4, we can easily prove the optimality of the proposed ConstructOutwardOkNVD algorithm as follows.

Proposition 5. 

When the ConstructOutwardOkNVD algorithm terminates, it can correctly construct outward OkNVDs in the road network.

Proof. 

It can be easily followed by Propositions 3 and 4. □

Based on the worst-case complexity of AddLinkToOkNVRs procedure (see Section 3.2), we can determine that the second stage of the ConstructOutwardOkNVD algorithm runs in $\mathrm{O}\left(\left|\mathrm{A}\right|k^2\mathrm{Log}\left(k\right)\right)$. Since its first stage runs in $\mathrm{O}\left(k\left|\mathrm{N}\right|\mathrm{Log}\left(\left|\mathrm{F}\right|\left|\mathrm{N}\right|\right)+k\left|\mathrm{A}\right|\right)$ (see Section 3.1), the ConstructOutwardOkNVD algorithm therefore runs in $\mathrm{O}\left(k\left|\mathrm{N}\right|\mathrm{Log}\left(\left|\mathrm{F}\right|\left|\mathrm{N}\right|\right)+\left|\mathrm{A}\right|k^2\mathrm{Log}\left(k\right)\right)$.

The proposed ConstructOutwardOkNVD algorithm can be modified easily to construct inward OkNVDs, namely the ConstructInwardOkNVD algorithm. Both FindKNearestPOIs and AddLinkToOkNVRs procedures should be modified by using the backward search (i.e., path extension to predecessor nodes) instead of the forward search (i.e., path extension to successor nodes). For example, the modified FindKNearestPOIs procedure should create a new path ${\tilde{p}}^{wf}:=a_{jw}\oplus p^{fj}$ from each predecessor node $n_w\in PRED\left(n_j\right)$ (see Lines 19 and 22). The ConstructInwardOkNVD algorithm has the same worst-case complexity as the ConstructOutwardOkNVD algorithm.

4. Numerical Experiments

This section reports the numerical experiments using real road networks. The proposed algorithm was implemented using the C# programming language. Section 4.1 reports their applications in place-based accessibility to supermarkets in Shenzhen, China; and Section 4.2 investigates their computational performance in several real road networks with different sizes.

4.1. Place-Based Accessibility to Supermarkets

In this study, Shenzhen, one of the most developed mega-cities in China, was selected as the study area. As shown in Figure 5a, Shenzhen is located in southern China, bordering Hong Kong to the south. It is the first Chinese special economic zone and experienced rapid socioeconomic development during the past decades. By the end of 2013, Shenzhen covered an area of approximately 1996 km² and had a total population of approximately 10.5 million, of which more than 70% were immigrants. Shenzhen has ten administrative districts with diverse land-use patterns. Among these districts, Nanshan, Futian and Luohu are core urban regions with dense residential and commercial areas; Bao’an, Longhua, Longgang, and Yantian are suburban regions with several new towns and industrial areas; and other three districts (Guangming, Pingshan, and Dapeng) are rural regions with large-scale agriculture and hilly lands as well as industrial areas.

Three datasets were collected for the case study. The first dataset was 39 large supermarkets in Shenzhen shown by star symbols in Figure 5a. The second dataset was the road network of Shenzhen city. As shown in Figure 5b, it consisted of 32,065 nodes and 81,618 directed links. The third dataset was trajectories of 17,406 taxis collected on a typical workday, i.e., 23 September 2014. These trajectories were matched onto the road network using a map matching algorithm [17], and then used to estimate and link travel time information during the evening peak hour (18:00–19:00) by using the method of Shi et al. [25].

Using supermarkets as generators, Figure 6a shows the constructed inward OkNVD when $k=1$. The generators are shown in star shape. The proposed algorithm constructed 39 inward OkNVRs, i.e., $v{r}_{in}^{1,i}$, for all generators. Each OkNVR, shown by a distinctive color, delimits a spatial region in which all locations share the same nearest generator. As can be seen, the sizes of OkNVRs are spatially heterogeneous in Shenzhen city with different supermarket densities, i.e., smaller at core urban and suburban regions (e.g., Nos. 1–5, 9–17 and 18–22) while larger at rural regions (e.g., Nos. 38 and 39). It can also be seen that all OkNVRs formed a tessellation on the Shenzhen network. They covered the whole network and they were mutually exclusive except at the boundary points.

Figure 6b shows OkNVD for large supermarkets in Shenzhen when $k=2$. As can be seen, the proposed algorithm constructed 149 inward OkNVRs, i.e., $v{r}_{in}^{2,i}$, in the study area. In this case, each constructed OkNVR delimits a spatial region in which all locations share the same set of the first and second nearest generators, $F_{in}^{q,2}$. Compared to the case of $k=1$, the sizes of $v{r}_{in}^{2,i}$ are smaller, especially for those areas with dense supermarkets. This result is obvious because all inward OkNVRs in the case of $k=2$ form a tessellation in the case of $k=1$. Each $v{r}_{in}^{1,i}$ is covered by one or more $v{r}_{in}^{2,i}$, which are mutually exclusive except at the boundary points. Figure 6c shows the corresponding OkNVD when $k=3$. In this case, the whole study area was partitioned into 320 inward OkNVRs, i.e., $v{r}_{in}^{3,i}$. The constructed OkNVRs when $k=3$ further form a tessellation when $k=2$.

Table 1. Characteristics of constructed OkNVRs under different k values.

k Value	Number of OkNVRs	Average Size of OkNVRs (km)	Total Network Size (km)
1	39	141.8	5530
2	149	37.1	5530
3	320	17.3	5530

summarizes the characteristics of OkNVRs under different $k$ values. As can be seen, the average size of OkNVRs (in terms of cumulative link lengths) was reduced with the increase of $k$ values. The total size of all OkNVRs under different $k$ values keep constant, i.e., 5530 km. This is because all OkNVRs at three levels ($k=1$ to 3) are stacked, forming a three-level hierarchical tessellation on the whole road network.

When constructing the inward OkNVD, the least travel times $\left\{t_1^{qf},\dots ,f_k^{qf}\right\}$ to $k$ nearest generators, $F_{in}^{q,K}=\left\{f_{in}^{q,1},\dots ,f_{in}^{q,K}\right\}$, for any location $q$ in the road network were calculated. These calculated travel times were employed to quantify the place-based accessibility to large supermarkets in Shenzhen and shown in Figure 7.

Figure 7a shows the accessibility pattern using the least travel time to the nearest supermarket, i.e., $t_1^{qf}$ calculated in the order first NVD. This is a classical indicator for measuring place-based accessibility in the literature [26]. As can be observed, the level of accessibility to large supermarkets is high for areas surrounded by at least one supermarket but low for those areas far from supermarkets. This indicator assumes that residents always go to the nearest supermarket for food purchases. However, several empirical studies have found that the most frequently used supermarkets by most residents are not the nearest supermarket to home [27]. As an extension to this classical indicator, Chen et al. [28] recently suggested using the average travel time (denoted by ${\overline{t}}_k^{qf}$) of the $k$ nearest supermarkets to better quantify accessibility to food retailers. Specifically, the accessibility level at location $q$ is calculated as follows:

$${\overline{t}}_k^{qf}=\left(t_1^{qf}+\dots +t_k^{qf}\right)/k$$

(11)

A smaller ${\overline{t}}_k^{qf}$ value implies the easer of a location for accessing supermarkets. This indicator can be directly obtained by using the results of OkNVD. Figure 7b shows the accessibility result using the indicator of ${\overline{t}}_k^{qf}$ when $k=2$. Compared to the classical indicator of $t_1^{qf}$, this indicator can well reveal the rural–urban disparity of accessibility to supermarkets caused by heterogeneous supermarket densities. The accessibility level was relatively high in the core urban regions (Nanshan, Futian, and Luohu) and relatively low in rural regions (Guangming, Pingshan, and Dapeng). For example, such indicators can well identify the low accessibility level for areas nearby Supermarket No. 39 in Dapeng district, since only one large supermarket is available in those areas. Similarly, a more distinct rural–urban disparity of accessibility can be observed when $k=3$ is used, see Figure 7c. As the value of k increases, the accessibility level of a location with low supermarket density would decrease rapidly, as they lack alternative supermarket supplies. However, a large k value could cover infeasible supermarkets with too large travel times. The selection of a suitable k parameter is critical for this accessibility measure. As suggested by Chen et al. [28], k = 3 is appropriate for supermarket accessibility studies.

4.2. Computational Experiments

This section reports the computational performance of the proposed algorithm. Previous Okabe’s algorithm [1] was also implemented for comparisons. Since Okabe’s algorithm did not provide the detailed procedure for the second stage, we employed that of our proposed algorithm. Both algorithms were coded in the same C# programming language and used the same F-heap data structure [24] as the priority queue. Since constructing inward and outward OkNVDs requires the same computational performance, we only report that of inward OkNVD constructions for simplicity. All experiments were conducted on a desktop with a four-core Intel 3.3 GHz CPU (only a single processor was used) and 8GB RAM running on Windows 10 operation system.

Table 2. Computational time of two algorithms in the Shenzhen network under different numbers of generators when k = 3 (in seconds).

Number of Generators	the Proposed Algorithm			Okabe’s Algorithm
	Stage 1	Stage 2	Total	Stage 1	Stage 2	Total
39	1.89	0.19	2.08	10.04	0.19	10.23
100	2.40	0.22	2.62	27.49	0.22	27.71
200	3.00	0.24	3.24	61.92	0.24	62.16
300	3.47	0.28	3.75	90.18	0.28	90.46
500	4.45	0.30	4.75	154.75	0.30	155.05
1000	4.60	0.31	4.91	305.19	0.31	305.50

reports the computational performance of both OkNVD construction algorithms in Shenzhen network under a different number of generators (i.e., $\left|F\right|$ values). Network nodes were randomly selected as new generators. The $k$ value was set as 3. As can be seen, the computational performance of Stage 1 dominates that of both algorithms. Therefore, we only examined the computational performance of Stage 1 hereafter.

It can be seen from the table that the computational time of Okabe’s algorithm (i.e., Stage 1) raised linearly with $\left|F\right|$. For example, when $\left|F\right|=100$, Okabe’s algorithm consumed 27.49 s to construct inward OkNVD in Shenzhen network. When $\left|F\right|=1000$, the computational time of this algorithm increased by 10.1 times (i.e., 305.19/27.49 − 1) to 305.19 s. This result is expected, mainly because Okabe’s algorithm calculates $\left|F\right|$ shortest paths at each node by constructing $\left|F\right|$ completed shortest path trees rooted at all generators. In addition, computational cost was required to sort $\left|F\right|$ shortest paths at each node.

As shown, the proposed algorithm has a much lower rate of degradation with the increase of $\left|F\right|$. When $\left|F\right|$ increases from 100 to 1000, its computational time raised by only 91.7% from 2.40 s to 4.60 s. This is because the proposed algorithm calculates only $k$ shortest paths at each node by constructing $\left|F\right|$ partial shortest path trees. Therefore, the proposed algorithm performed significantly faster than Okabe’s algorithm by calculating much less shortest paths, especially for the scenarios of large $\left|F\right|$. As shown, the proposed algorithm ran 10.45 (i.e., 27.49/2.40 − 1) times faster than Okabe’s algorithm when $\left|F\right|=100$. This computational advantage further increased to 65.34 times when $\left|F\right|=1000$. Such computational advantage is important for real applications commonly with large $\left|F\right|$, for example $\left|F\right|=6899$ in Chen et al. [6].

Figure 8 shows the computational performance of both OkNVD construction algorithms in Shenzhen network under different $k$ values. The number of generators was set as 500. As can be seen, the computational performance of Okabe’s algorithm is stable under different $k$ values. It is obvious, since Okabe’s algorithm calculates $\left|F\right|$ shortest paths at each node regardless of different $k$ settings. It can be seen that the computational performance of the proposed algorithm degraded linearly with the increase of $k$ value. This is because the proposed algorithm calculates $k$ shortest paths at each node. The larger the k value was, the more shortest paths were calculated. In practice, the $k$ value is usually low, e.g., $k\le 5$ [28]. It should be noted that the proposed algorithm ran still significantly better than Okabe’s algorithm various $k$ values under various $k$ values.

Table 3. Computational time of both testing algorithms under different network sizes when k = 3 and $\left|F\right|=500$ (in Seconds).

Network	Node Number	Link Number	Proposed Algorithm	Okabe’s Algorithm	Computational Improvement
Xiamen	1997	6252	0.19	7.17	36.73
Wuhan	19,306	52,810	2.54	91.68	35.09
Shenzhen	32,065	81,618	4.73	155.03	31.77
Shanghai	95,128	248,166	20.40	782.61	37.36
Beijing	111,544	304,494	29.75	1087.47	35.55

reports the computational performance of both testing algorithms in five real road networks with different sizes. The number of generators was selected as 500 and the k value was set as 3. Generators were randomly selected from the network nodes. As shown, the computational times of both testing algorithms increased with the network size. This result is expected, since the computational performance of shortest path algorithms themselves degraded with the network size [19]. It can be seen that the proposed algorithm performed consistently better than Okabe’s algorithm in all road networks with different sizes. For example, in a small network of Xiamen, the proposed algorithm consumed 0.19 s to construct inward OkNVD, which was 36.73 times (i.e., 7.17/0.19 − 1) faster than Okabe’s algorithm. This computational improvement remained relatively stable in all networks ranging from 31 to 37 times.

5. Conclusions

The order k network Voronoi diagram (OkNVD) is an effective geometric construction to partition the network space into a set of order k network Voronoi regions (OkNVRs) such that all locations within an OkNVR share the same k nearest generators. Despite the broad applications of OkNVD, few effective and efficient algorithms had been developed to construct OkNVD in real road networks. This study proposed a novel OkNVD construction algorithm consisting of two stages. In the first stage, a new one-to-all k shortest path procedure was proposed to efficiently determine the k nearest generators for each network node in a single shortest path search process. This proposed procedure improves the worst-case complexity from previous $\mathrm{O}(\left|\mathrm{F}\right|\left|\mathrm{N}\right|\mathrm{Log}\left(\left|\mathrm{N}\right|\right)+\left|\mathrm{F}\right|\left|\mathrm{A}\right|+\left|\mathrm{N}\right|{\left|\mathrm{F}\right|}^2)$ [1] to $\mathrm{O}\left(k\left|\mathrm{N}\right|\mathrm{Log}\left(\left|\mathrm{F}\right|\left|\mathrm{N}\right|\right)+k\left|\mathrm{A}\right|\right)$. In the second stage, a new recursive procedure was introduced to effectively divide boundary links into different OkNVRs using the hierarchical tessellation property. The introduced procedure can effectively solve the link division issue that had not been addressed by the previous study [1].

To demonstrate the applicability of the proposed OkNVD construction algorithm, a comprehensive case study in Shenzhen city was carried out. Results of the case study demonstrated that the proposed OkNVD construction algorithm can well quantify place-based accessibility in a fine-gained spatial resolution. Results of computational experiments showed that the proposed algorithm was significantly faster than previous Okabe’s algorithm for all five testing networks under different k and $\left|\mathrm{F}\right|$ settings. For example, it performed about 65 times faster than Okabe’s algorithm in the Shenzhen network when k = 3 and $\left|\mathrm{F}\right|=1000$. This computational advantage would be more obvious in real large-scale applications, in which the number of generators $\left|\mathrm{F}\right|$ are large and the k value is small.

Several directions for future research are worth pursuing. Firstly, this study assumed that link costs are static and deterministic. Traffic conditions in real road networks are dynamic and stochastic [29]. How to incorporate such dynamic and stochastic travel times into the proposed algorithm needs further investigation. Secondly, the proposed algorithm considers only the road transport mode. The extension of this proposed algorithm into the multi-mode transport networks, such as metro and bus, is warranted for further study. Last but not least, finding k nearest generators is a critical step for many network analyses, such as spatial interpolation, spatial clustering, outlier detection, and k nearest neighbor query, etc. [12,14,28]. Subsequent studies should investigate how to incorporate the proposed algorithm in these network analysis methods.