Graph Indexing of Road Networks for Shortest Path
Queries with Label Restrictions
Michael Rice
University of California, Riverside
Riverside, CA 92521
mrice@cs.ucr.edu
Vassilis J. Tsotras
University of California, Riverside
Riverside, CA 92521
tsotras@cs.ucr.edu
ABSTRACT
The current widespread use of location-based services and
GPS technologies has revived interest in very fast and scal-
able shortest path queries. We introduce a new shortest path
query type in which dynamic constraints may be placed on
the allowable set of edges that can appear on a valid short-
est path (e.g., dynamically restricting the type of roads or
modes of travel which may be considered in a multimodal
transp ortation network). We formalize this problem as a
specific variant of formal language constrained shortest path
problems, which we call the Kleene Language Constrained
Shortest Paths problem. To efficiently support this type of
dynamically constrained shortest path query for large-scale
datasets, we extend the hierarchical graph indexing tech-
nique known as Contraction Hierarchies. Our experimental
evaluation using the North American road network dataset
(with over 50 million edges) shows an average query speed
and search space improvement of over 3 orders of magni-
tude compared to the na¨ıve adaptation of the standard Di-
jkstra’s algori thm to support this query type. We also show
an improvement of over 2 orders of magnitude compared to
the only previously-existing indexing technique which could
solve this problem without additional preprocessing.
1. INTRODUCTION
Due to its ubiquitous usage over the web and in many
commercial navigation products, point-to-point shortest path
search on graphs has again become a major topic of inter-
est over the last decade, with much research being devoted
to designing practical indexing techniq ues for extremely fast
graph searches. Graph indexing techniques have been wi dely
explored for establishing efficient data structures for prun-
ing and/or directing the search of shortest path algorithms,
while still guaranteeing the optimality of the resulting paths.
Such techniques have resulted in many improvements over
the standard Dijkstra’s algorithm [6], and may also be used
to minimize the overall I/O costs incurred by the graph
search for very l arge, external-memory graph datasets [10,
Permission to make digital or hard copies of all or part of this work for
personal or classroom use is granted without fee provided that copies are
not made or distributed for profit or commercial advantage and that copies
bear this notice and the full citation on the first page. To copy otherwise, to
republish, to post on servers or to redistribute to lists, requires prior specific
permission and/or a fee. Articles from this volume were invited to present
their results at The 37th International Conference on Very Large Data Bases,
August 29th - September 3rd 2011, Seattle, Washington.
Proceedings of the VLDB Endowment, Vol. 4, No. 2
Copyright 2010 VLDB Endowment 2150-8097/10/11... $ 10.00.
15]. However, focus thus far has been mostly on static short-
est paths with no constraints.
In this research, we focus on a variant of shortest path
queries in which dynamic constraints may be placed upon
the type of edges which may appear on a valid shortest path.
For example, the shortest path from Irvine, CA to Riverside,
CA travels along State Route 261, which is a local toll road
through this area. However, consider the case where the
traveler does not wish to pay the toll fee, and would there-
fore rather find the shortest path from Irvine to Riverside
that actually avoids all toll roads. As yet another ex am-
ple, trucks delivering certain hazardous materials may not
be allowed to cross over some types of roadways, such as
bridges or railroad crossings, due to the public health and
safety risks of any potential accidents. Therefore, this query
type can be seen to have practical applications in b oth per-
sonalized location-based services, as well as in many logistics
and commercial transportation scenarios. Making this query
highly efficient on real-world, large-scale graphs, such as the
road network of the continental United States, is therefore
crucial to effectively supporting such practical applications.
1.1 Related Work
In recent years, hierarchical graph indexing techniques
have been shown to be some of the most time- and space-
efficient approaches towards indexing graphs for shortest
path computations [8, 15, 16, 4, 13, 14, 12]. Hierarchi-
cal techniques generally involve some classification of the
vertices/edges within the graph into mutually-exclusive, or-
dered levels of hierarchy, based on some notion of impor-
tance within the graph structure. Shortest path queries
carried out on a hierarchical graph index typically prefer
searching towards higher (i.e., more important) levels of the
graph hierarchy, while progressively ignoring lower (i.e., less
important) levels of the hierarchy, in order to more effec-
tively reduce the overall search space explored by the query.
Schultes and Sanders [16] have previously explored a vari-
ant of their hierarchical indexing techniques designed to sup-
port dynamic changes in graph edge weights or cost func-
tions. However, support for this dynamic approach requires
either explicit recomputation of the graph index online as
the weights (or cost functions) change or the query algo-
rithm must make increasingly limited use of the information
available in the static graph index based on the dynamic
changes.
Yet another practical graph indexing approach is the goal-
directed approach of the ALT algori thm [9, 10]. The ALT
algorithm is based primarily on the concepts of A* search
[11], in which the search from a source no de is “directed”
69
towards the target node by the use of a potential function to
estimate the shortest path cost to the target. The ALT algo-
rithm allows preprocessing in which a set of so-called land-
mark nodes is selected from the graph and the shortest path
is computed for each landmark node to/from all other no des
in the graph. Using properties of the triangle inequality de-
rived from the costs to/from all landmark nodes, a highly
efficient potential function can be constructed, thus greatly
reducing the resulting search space. This technique has been
further studied within the context of dynamic graphs in [5],
and it can be shown that the potential functions from the
original landmark preprocessing remain correct for all short-
est paths as long as the edge weights can only increase in a
dynamic scenario.
In the context of our own constrained shortest path query
presented here, the idea of dynamically restricting an edge
from being allowed in the search for a particular query can
be seen as equivalent to simply increasing the weight of that
edge to infinity for the lifetime of the query. Thus, the ALT
technique is the only existing indexing technique directly
applicable to our query type without requiring additional or
specialized preprocessing.
1.2 Our Contributions
To the best of our knowledge, this is the first work to
address this practical variant of shortest path query. In
particular, our contributions can be summarized as follows.
We formalize this problem as a restricted class of language
constrained shortest paths, thus tying it to the existi ng lit-
erature and giving this new problem some relative context.
To efficiently support this type of dynami cally constrained
shortest path query, we detail a practical and efficient ap-
proach to extend the hierarchical graph indexing technique
known as Contraction Hierarchies [8, 7]. Given implicit
knowledge of the range of possible constraints for short-
est path querie s on a graph, we propose to incorporate this
knowledge directly into the graph index construction to avoid
the overhead of reconstructing the index for each possible
constraint scenario at query time.
Using one of the largest commercial real-world road net-
work datasets, we present ex perimental results with im-
provements of over 3 orders of magnitude compared to the
na¨ıve adaptation of the standard Dijkstra’s algorithm
1
to
support this query type. We also show an improvement of
over 2 orders of magnitude compared to the dynamic ALT
algorithm examined in [5].
The remainder of the paper is organized as follows. In Sec-
tion 2, we present the concept of constraints on the allowable
edges for a given shortest path query as a specific variant
of language constrained shortest paths. Section 3 presents
an overview of Contraction Hierarchies. Section 4 extends
this technique with the proposed algorithms for constructing
and queryi ng the hierarchical graph index to support these
constraints for shortest path queries. Section 5 presents our
experimental analysis of this technique. Finall y, Section 6
concludes the paper with future research.
2. LANGUAGE CONSTRAINED SHORTEST
PATHS
Language constrained shortest paths [3] are shortest paths
whose edge labels must satisfy some formal language con-
1
We refer here to the more efficient bidirectional version.
straint over a fixed alphabet Σ. We define this concept more
formally as follows. Let G = (V, E, w, Σ, `) be a directed
graph, where V is the set of vertices in G, E is the set of
edges in G, w : E → R
+
is a function mapping edges in G to
a positive, real-valued weight, Σ is a finite alphabet used for
labeling of edges in G, and ` : E → Σ is a function mapping
edges in G to a label in Σ.
Let P
s,t
= he
1
, e
2
, · · · , e
k
i be any path in G from some ver-
tex s ∈ V to some vertex t ∈ V , such that e
1
= (s, v
1
) ∈ E,
e
k
= (v
k−1
, t) ∈ E, and for 1 < i < k, e
i
= (v
i−1
, v
i
) ∈ E.
Let w(P
s,t
) =
P
1≤i≤k
w(e
i
) be the total weight of all edges
in P
s,t
. Let `(P
s,t
) = `(e
1
)`(e
2
) · · · `(e
k
) be the concate-
nation of the labels of all edges in P
s,t
. Given any formal
language L ⊆ Σ
∗
, a language constrained shortest path is a
path P
0
s,t
in G such that `(P
0
s,t
) ∈ L and ∀ P
s,t
in G where
`(P
s,t
) ∈ L, w(P
0
s,t
) ≤ w(P
s,t
).
The Regular Language Constrained Shortest Paths (RLC-
SP) problem is a basic variant of language constrained short-
est paths where the constraint language L must be a regu-
lar language. In [3, 1], Barrett et al. show that RLCSP is
solvable in polynomial time by performing a shortest path
search in the product graph of the original graph and the
non-deterministic finite automaton (NFA) graph represent-
ing the specified regular language.
The Linear Regular Expression (LRE) constrained short-
est paths problem [2] is a variation of RLCSP in which the
regular expressions representing the constraint-language L
must be of a specific form related to a restricted subclass
of regular languages. In particular, linear regular expres-
sions must be of the form x
+
1
x
+
2
· · · x
+
k
, where for 1 ≤ i ≤ k,
x
i
∈ Σ, and x
+
i
= x
i
x
∗
i
.
LRE is presented primarily as a means of expressing modal
constraints on real-world transportation networks , where a
traveler knows the exact modes of travel (i.e., labels) they
wish to consider and the exact order in which they wish to
travel through these modes. One drawback to this approach
is that such information may not always be known by the
traveler in advance. For example, the traveler may not know
the best order of modes to take in their trip; however, they
are still likely to know exactly which modes they are ulti-
mately willing to take (as well as those modes which they
are unwilling to take). Therefore, we present a new vari-
ant of language constrained shortest paths (below) designed
specifically to support this more flexible scenario.
2.1 Kleene Language Constrained Shortest
Paths
We present the Kleene Language Constrained Shortest Pa-
ths (KLCSP ) problem as a variant of language-constrained
shortest paths based on another (simpler) subclass of regular
languages which we shall call here the Kleene languages.
A Kleene language may be defined in this context as the
Kleene closure of any subset of Σ. More formally, ∀A ⊆ Σ,
L(A
∗
) defines a Kleene language over alphabet A. Note that
the subset alphabet A merely defines the set of allowable
labels that can appear on a valid shortest path for a KLCSP
problem. However, unlike LRE, the lab el s in A are not
required to appear on a shortest path for a KLCSP problem
and the sequence of the labels of such a path is irrelevant.
Additionally, for any Kleene language over A ⊆ Σ, there is
an implicitly defined subset of restricted labels R = Σ \ A,
such that no labels in R may appear on any valid KLCSP
solution. A Kleene language over A ⊆ Σ may therefore
70
be equivalently defined simply by specifying the set of such
restricted labels, R, where A = Σ \ R. Given this definition,
the KLCSP problem is designed to support the specification
of language constraints on the allowed (restricted) set of
labels which may (not) appear over a given shortest path, in
any permutation. It is considered more common in practice
to specify this constraint as the set of restricted labels , R,
so we will adopt this approach for the remainder of this
do cum ent.
For example, consider a transportation network consist-
ing of labels Σ = {l, h, i, t, f}, which represent local roads,
highways, interstates, toll roads, and ferries, respectively.
A traveler may wi sh to find the shortest path between two
locations in the network that avoids both toll roads and fer-
ries. A Kleene language supporting this constraint could be
defined as L((Σ \ {t, f })
∗
).
The practical applications of KLCSP are also not restricted
merely to modal constraints on a shortest path query. A la-
bel in Σ can correspond to any arbitrary predicate condition
associated with the edges of the graph. In later sections deal-
ing with the graph index construction, we must extend the
notion of edge labels to include support for multiple labels
per edge. This also proves highly useful in scenarios where
a given edge can support multiple such predicate conditions
simultaneously.
In order to support this, we redefine the function ` to
support multiple labels per edge as follows: ` : E → P(Σ)
is the labeling function mapping edges to a set of labels in
Σ (where P(Σ) denotes the power set of Σ). Since this new
function can now map a given edge to multiple potential
labels, we must also redefine what it means for a path P
s,t
to be valid for a given Kleene language constraint. We say
that an R-restricted path is any path P
s,t
= he
1
, e
2
, · · · , e
k
i,
such that, for 1 ≤ i ≤ k, `(e
i
) ∩ R = ∅ (i.e., the path
avoids all restricted labels in R). We denote the shortest
R-restricted path from s ∈ V to t ∈ V as P
R
s,t
.
Unlike the algorithms for RLCSP and LRE, which require
a search through a product graph, this simple subclass of
regular languages allows for a much more efficient optimiza-
tion of the constrained shortest path search. In particu-
lar, we need now only verify that a given edge’s labels do
not belong to the restricted subset of labels, as indicated
by R, before relaxing the edge in the search. We present
the pseudocode for solving the KLCSP problem using a
straightforward adaptation of Dijkstra’s algorithm in Algo-
rithm 1. Note that a similar bidirectional search can also be
performed instead of the unidirectional search presented in
this pseudocode. We present the unidirectional variant here
merely for simplicity and greater ease of understanding.
3. CONTRACTION HIERARCHIES (CH)
CH [8, 7] have been proposed as an efficient graph in-
dexing technique for supporting static point-to-point short-
est path queries. The primary idea of CH is to es tablis h
some absolute ordering of the vertices in the graph (i.e., the
ordering defines a bijective function φ : V → {1, ..., |V |})
with respect to s ome notion of general, relative importance.
Given such an ordering, preprocessing proceeds by “con-
tracting” one vertex at a time, in increasing order of impor-
tance. When a vertex, v, is contracted, it is removed from
the current graph “in such a way that shortest paths in the
remaining...[sub]graph are preserved” [8]. In particular, for
any pair of remaining vertices, u and w, adjacent to v in the
Algorithm 1 KLCSP-Dijkstra(G, s, t, R)
Input: Graph G = (V, E, w, Σ, `), s, t ∈ V , restricted alpha-
bet R ⊆ Σ
Output: Cost of shortest path P
R
s,t
1: P Q ← ∅
2: for all v ∈ V do
3: d[v] ← ∞
4: end for
5: d[s] ← 0
6: P Q.Insert(s, d[s])
7: while ¬P Q.Empty() do
8: u ← P Q.ExtractMin()
9: if u = t then
10: return d[t]
11: end if
12: for all e = (u, v) ∈ E do
13: if `(e) ∩ R = ∅ ∧ d[u] + w(e) < d[v] then
14: d[v] ← d[u] + w(e)
15: if v /∈ P Q then
16: P Q.Insert(v, d[v])
17: else
18: P Q.DecreaseKey(v, d[v])
19: end if
20: end if
21: end for
22: end while
23: return ∞
original graph whose only shortest u-w path is hu, v, wi, a
so-called shortcut edge (u, w) must be added with the weight
of the original shortest path cost through v (see Figure 1 for
an example). However, if there is an equivalent- or lesser-
cost path from u to w other than hu, v, wi, then no such
shortcut edge is needed. Such a path is called a witness
path. In order to detect w itness paths, a local search from
all nodes u, such that (u, v) ∈ E and φ(u) > φ(v), to all
no de s w, such that (v, w) ∈ E and φ(v) < φ(w), is carried
out to determine if a (u, w) s hortcut edge is necessary.
(
7)
(4
)
(
3
)
(
3
)
(2
)
(
3
)
v
u
w
x
y
Figure 1: Contracting node v. Edges are labeled
with their weights. The shortcut edge is represented
with a dashed line.
Note that the number of shortcut edges added when con-
tracting a graph is heavily dependent on the given ordering.
Therefore, establishing a good ordering is one of the most
crucial aspects of this methodology. In [8], Geisberger et
al. establish several metrics to be associated with a given
no de that can help in determining the overall priority of
that node in the ordering. In this context, vertex order-
71
ing is directly i ntegrated into the contraction phase by first
simulating the contraction of a given node to determine its
resulting priority terms, and ordering the nodes in a priority
queue based on a linear combination of these terms. Some
of these metrics include: the difference between the num-
ber of shortcut edges added and the number of adjacent
edges removed when contracting a node (edge differen ce),
the number of nei ghbors of a node that have already been
contracted (contracted neighbors), and the number of orig-
inal edges represented by any new shortcuts added when
contracting a node (original edges). The interested reader
is referred to [ 8, 7] for a more exhaustive list and greater
details on each priority term considered. At each iteration,
the node with minimum priority value is removed from the
priority queue, contracted, and the priority values of all of
its neighboring vertices are updated for the next iteration.
Once the set of shortcut edges, E
0
, has been established
for a given ordering, shortest path queries may then be car-
ried out using a bidirectional Dijkstra search variant which
performs a simultaneous forward search in the upward graph
G
↑
= (V, E
↑
), where E
↑
= {(v, w) ∈ E ∪ E
0
| φ(v) < φ(w)},
and backward search
2
in the downward graph G
↓
= (V, E
↓
),
where E
↓
= {(u, v) ∈ E ∪ E
0
| φ(u) > φ(v)}. A tentative
shortest path cost is maintained and is updated only when
the two search frontiers meet to form a shorter path. The
search in a given direction may be aborted once the mini-
mum key for the priority queue in that direction exceeds the
cost of the best tentative path seen so far. Once both search
directions are finished, the best path seen thus far represents
the shortest path cost. An illustration of this bidirectional
search is given in Figure 2.
s
t
G
G
Figure 2: CH bidirectional search query. The re-
sulting shortest path is indicated by the thick lines.
As with any graph search algorithm, the efficiency of the
search process is directly proportional to the number of
no de s and edges explored during the search. The effective-
ness of the CH search technique therefore comes from the
use of the newly-added shortcut edges, which allow the Di-
jkstra search to effectively bypass irrelevant nodes during
the se arch, without invalidating correctness, thus resulting
in a greatly-reduced search space (and therefore, better run-
time), as compared to the standard Dijkstra search on the
original graph.
4. CONTRACTION HIERARCHIES WITH
LABEL RESTRICTIONS (CHLR)
Despite the na¨ıve adaptation of Dijkstra’s algorithm to
support the Kleene language constrained shortest paths, as
2
Backward search in a graph G = (V, E) is the equivale nt
of performing a standard (i.e., forward) search in the graph
¯
G = (V,
¯
E), where
¯
E = {(v, u) | (u, v) ∈ E}.
presented in Algorithm 1, this variation is still prohibitively
slow on large graph datasets, as will be demonstrated later
in our experimental results section. We therefore present the
first enhancements to the hierarchical graph indexing con-
cepts of Contraction Hierarchies to support KLCSP prob-
lems as follows. We start with a brief overview of the ex-
isting limitations of Contraction Hierarchies for solving this
particular problem below.
4.1 Limitations of CH
In order to showcase the limitations of CH for Kleene lan-
guage constrained shortest paths, let us consider a simple ex-
ample graph with label alphabet Σ = {r, g, b}, representing
the colors red, green, and blue, respectively. This example
graph is illustrated in Figure 3, where the edges have been
colored according to their respective labels. In this scenario,
when node v is contracted, a local search will be performed
to find a potential witness path from node u to node w in the
graph induced by the set of nodes “higher” in the hierarchy
than node v (e.g., nodes u, w, x, and y). This local search
will find a witness path, hu, x, y, wi, with cost equal to 8,
which happens to be less than the cost of the path hu, v, wi,
which is 10. In this case, no shortcut will be added between
no de s u and w during the pre-processing. However, if we
later wish to perform a Klee ne language constrained short-
est path query from u to w, in which we restrict the color
red from our shortest path (i.e., our language constraint is
L((Σ \ {r})
∗
)), then the bidirectional search will be unable
to find any such path between u and w (since there are no
valid shortcuts between u and w and the edge (x, y) will be
invalid based on its red label), even though there exists a
valid shortest path that avoids the color red in this graph:
the path hu, v, wi with cost 10.
One na¨ıve solution to this problem would be to establish
a s eparate graph index for all possible subsets of the label
alphabet Σ, and then use the appropriate index based on the
incoming query constraints R. However, this is prohibitive,
and would require the construction and mai ntenance of 2
|Σ|
separate index datasets. Therefore, in the following sections,
we propose methods to extend the concepts of Contraction
Hierarchies to properly support any Kleene language con-
straints, and we prove the correctness of this approach, as
well as providing experimental evidence in favor of this ap-
proach over other existing techniques (e.g., ALT).
(
?)
(6
,
{
g
}
)
(
4
,{
b
}
)
(
3,
{
b
}
)
(
2
,
{
r
}
)
(
3
,
{
b
}
)
v
u
w
x
y
Figure 3: Contracting a labeled graph. Each edge,
e, is labeled as (w(e), `(e)).
4.2 CHLR Index Construction
The revised contraction algorithm for graph index con-
struction (shown in Algorithm 2) works as follows. The
72
Algorithm 2 KLCSP-Contraction(G, φ)
Input: Graph G = (V, E, w, Σ, `) and bijective node order
function φ : V → {1, ..., |V |}
Output: Augmented graph G
0
= (V, E ∪ E
0
, w, Σ, `), where
E
0
represents newly-added shortcut edges
1: G
0
← G
2: E
0
← ∅
3: for all v ∈ V ordered by φ do
4: for all e
↓
= (u, v) ∈ E ∪ E
0
ordered by w(e
↓
) :
φ(u) > φ(v) do
5: for all e
↑
= (v, w) ∈ E ∪ E
0
ordered by w(e
↑
) :
φ(v) < φ(w) ∧ w 6= u do
6: G
0
v
← G
0
[{z ∈ V | φ(v) < φ(z)}]
7: R ← Σ \ {`(e
↓
) ∪ `(e
↑
)}
8: shor tcutCost ← w(e
↓
) + w(e
↑
)
9: witnessCost ← KLCSP-Dijkstra(G
0
v
, u, w, R)
10: if shortcutCost < witnessCost then
11: e
0
← (u, w)
12: w(e
0
) ← shortcutCost
13: `(e
0
) ← {`(e
↓
) ∪ `(e
↑
)}
14: E
0
← E
0
∪ {e
0
}
15: G
0
← G
0
∪ E
0
16: end if
17: end for
18: end for
19: end for
20: return G
0
algorithm processes each node v ∈ V in the order defined by
φ (which, for simplicity, we may assume is pre-defined). For
each such node v, the algorithm considers all possible pairs of
incoming edges e
↓
= (u, v) and outgoing edges e
↑
= (v, w),
such that both u and w occur after v in the ordering de-
fined by φ (i.e., they occur “higher” in the hierarchy). For
each such pair of edges, the algorithm performs a KLCSP-
Dijkstra search in the subgraph defined by G
0
v
(the subgraph
of G
0
induced by nodes with “higher” hierarchy than v), us-
ing the set of restricted labels, R, defined to be the set of
labels “avoided” (or not supported) by both e
↓
and e
↑
. If
the KLCSP-Dijkstra search is able to find an equivalent- or
lesser-cost path than the path hu, v, wi, which also avoids the
same set of restricted labels avoided by both e
↓
and e
↑
, then
no shortcut edge is necessary (since there can be no possible
constraint scenario for which the path hu, v, wi is required).
Edges are processed in order of increasing weight (see Lines
4 and 5) to ensure that the total number of shortcut edges
constructed by this pro ces s is minimal for the given ordering
φ. See the appendix for a formal proof of both correctness
and minimality.
4.2.1 Multi-Edge Support
One important aspect of the enhancements to the graph
contraction al gorithm shown above is that our graph index
must now support multi-edges (i.e., parallel edges) due to
the potential for multiple possible paths between a given
pair of no des in the graph, depending upon the set of re-
stricted labels chosen for the query. For example, in the
graph illustrated in Figure 4, if the nodes are contracted in
order from bottom to top, we must now insert two separate
shortcut edges between nodes u and w: edge e is neces-
sary when contracting node v and edge e
0
is necessary when
contracting node v
0
. Note that, in this particular case, we
cannot simply replace one shortcut edge with the other when
added, since they might both be necessary for ensuring cor-
rectness of the resulting shortest paths, depending upon the
set of restricted labels. In particular, if the restricted label
set is R = {r, b}, then the shortest path between u and w
will make use of the shortcut edge e, giving a cost of 10 and a
final (expanded) path of hu, v, wi. However, if the restricted
label set is R = {r, g}, then the shortest path between u and
w will make use of the shortcut edge e
0
, giving a cost of 12
and a final (expanded) path of hu, v
0
, wi.
(
7
,{b
}
)
(
5
,
{
b
})
v'
(6
,
{
g
}
)
(
4
,{
g
}
)
(
3,
{
b
}
)
(
2
,
{
r
}
)
(
3
,
{
b
}
)
v
u
w
x
y
e
(
10
,{g
}
)
e'
(
12
,{b
}
)
Figure 4: Multi-edge example.
4.3 CHLR Index Queries
Once the CHLR hierarchy has been established with the
shortcut edge set, E
0
, shortest path queries for any given
restricted label set, R ⊆ Σ, may then be carried out as
follows. The search algorithm employed is the same bidirec-
tional Dijkstra search variant as is used for the static CH
query algorithm (described in Section 3). However, we must
now further augment the resulting upward and downward
search graphs explored for a given query, respective of R.
We redefine the upward search graph as G
↑
= (V, E
↑
), where
E
↑
= {e = (v, w) ∈ E ∪ E
0
| φ(v) < φ(w) ∧ `(e) ∩ R = ∅},
and the downward graph as G
↓
= (V, E
↓
), where E
↓
= {e =
(u, v) ∈ E ∪ E
0
| φ(u) > φ(v) ∧ `(e) ∩ R = ∅}. The CHLR
query will now explore only those edges whose label sets are
valid for the given query constraints.
4.4 Optimizations
As indicated in the KLCSP-Contraction index construc-
tion algorithm, during the contraction of a given node v,
where I
↓
v
= {(u, v) ∈ E ∪ E
0
| φ(u) > φ(v)} and O
↑
v
=
{(v, w) ∈ E ∪ E
0
| φ(v) < φ(w)}, the algorithm p e rforms a
total of |I
↓
v
| · |O
↑
v
| calls to KLCSP-Dijkstra
3
. While correct
and minimal (for a given ordering φ), the overall efficiency
of the contraction of v can be improved by instead perform-
ing only a single local search from the source, u, of each
incoming edge e
↓
= (u, v) ∈ I
↓
v
until all nodes in the set
W = {w ∈ V | (v, w) ∈ O
↑
v
} have been settled, or until a
distance of w(e
↓
) + max{w(e
↑
) | e
↑
= (v, w) ∈ O
↑
v
, w 6= u}
has been reached (this is sim il ar to the approach used in
[8]). Using this approach we can set R ← Σ \ `(e
↓
) and
pass this restricted label set to the augmented version of
KLCSP-Dijkstra. Note that this does not affect the correct-
ness of the resulting index, since the set R that we pass to
KLCSP-Dijkstra in this case is a superset of the restricted
label set passed to the KLCSP-Dijkstra calls in the original
algorithm, for all possible pairs of incoming and outgoing
3
Pairs he
↓
= (u, v), e
↑
= (v, w)i where u = w are ignored.
73
