Label-Setting Algorithm for Multi-Destination K Simple Shortest Paths Problem and Application

Abstract

The k shortest paths problem finds applications in multiple fields. Of particular interest in the transportation field is the variant of finding k simple shortest paths (KSSP), which has a higher complexity. This research presents a novel label-setting algorithm for the multi-destination KSSP problem in directed networks that obviates repeated applications of the algorithm to each destination (necessary in existing deviation-based algorithms), resulting in a significant computational speedup. It is shown that the proposed algorithm is exact and flexible enough to handle several variants of the problem by appropriately modifying the termination condition. Theoretically, it is also shown to be faster than state-of-the-art algorithms in sparse and dense networks whenever the number of labels created is sub-polynomial in network size. A heuristic method and optimized data structures are proposed to improve the algorithm’s scalability and worst-case performance. The computational results show that the proposed heuristic provides two to three orders of magnitude computational time speedups (29–1416 times across different networks) with negligible loss in solution quality (maximum average deviation of 0.167% from the optimal solution). Finally, a practical application of the proposed method is illustrated to determine the gravity of an edge (relative structural importance) in a network.

1. Introduction

Shortest-path algorithms are widely applied in many areas, such as transportation, telecommunication, optimization, and computer science [1,2,3]. Numerous efficient algorithms have been developed to address this problem and its variants, such as the $k$ shortest path (KSP) problem [4], the $k$ simple shortest path (KSSP) problem [5], and the time-dependent shortest path problem [6]. To provide the necessary context, we briefly introduce the concepts of KSP and KSSP. Informally, KSP refers to the top $k$ shortest paths between two points in a network. If we impose the additional constraint that these paths must not contain any repeated nodes, we are dealing with KSSP. Rigorous definitions are provided in Section 3. While the multiple origin and destination versions of the shortest path problem have received specialized attention, the KSSP problem remains under-researched for the multiple destinations case. This problem class encompasses different variants that arise in several practical applications described below. However, current algorithmic approaches predominantly revolve around the use of naïve and repetitive application of the single destination algorithm, thereby ignoring the distinct characteristics of the class as well as opportunities for computational efficiency. Therefore, this paper focuses on the multi-destination KSSP problem by developing specialized solution procedures based on the label-setting framework.

There are applications where finding KSSP to multiple destinations is necessary. One such example is the multi-path routing of vehicles to multiple destinations at the end of mass gathering events, such as sporting events and concerts. Another practical problem relates to routing last-mile connectivity fleets from a transit station to multiple passenger destinations [7]. Other applications where such a solution may be useful include routing autonomous vehicles under dynamic traffic scenarios to multiple activity locations [8], navigation to multiple destinations in complex indoor environments [9], and evacuating people through multiple paths from a building under hazard to multiple safe shelters.

The last decade has witnessed an increasing number of efficient algorithms and heuristics for the KSSP problem to improve upon the popular Yen’s algorithm [10,11,12,13]. These algorithms, however, have been designed and implemented for the single destination case, whereas KSSP algorithms from a single origin to multiple destinations remain relatively scarce in the literature. The KSSP problem from a single source to all destinations (one-to-all) requires finding the top $k$ simple shortest paths to each node in the network. The multi-destination KSSP encompasses a class of problems with several variants. Two variants are presented in this paper, listed below. Besides the one-to-all KSSP, these variants include finding (i) the top $k$ simple shortest paths to each node from a subset of destinations if they exist and (ii) all the simple shortest paths from the origin to any destination within a time or cost budget.

The KSSP, even for the single destination case, is more complex than the KSP due to the constraint of cycle-free paths, though it provides realistic paths. While existing single-destination KSSP algorithms can be extended in a straightforward manner to accommodate multiple destinations, this approach is computationally inefficient due to redundant shortest-path computations to the same intermediate node for different destinations in the existing deviation-based approaches. Therefore, motivated by the above shortcomings in the literature, the aim of this paper is to propose a novel label-setting algorithm as an efficient solution for the multiple destinations case, diverging from the prevalent deviation-based, path replacement, or label-correcting approaches available in the literature. This approach takes advantage of the cost and predecessor information on a path (from origin to intermediate nodes) while calculating the KSSP to downstream multiple destination nodes. Thus, the algorithm is able to explore all destinations concurrently in a single run, resulting in significant computational performance gains.

The specific objectives of this study include the following:

• Propose a label-setting framework for a class of multi-destination KSSP problems and identify optimality conditions to find exact solutions for the identified variants.
• Develop an exact label-setting solution algorithm for solving the one-to-all KSSP problem and analyze its computational complexity.
• Propose a heuristic for practically efficient implementation using bounded labels and appropriate data structures.
• To evaluate the computation performance and solution quality of the proposed approach with state-of-the-art algorithms on various real-world networks.
• To illustrate the application of this algorithm for a practical problem and demonstrate its efficacy for the use case.

This study contributes to the literature by introducing a novel label-setting algorithm for the multi-destination KSSP problem. The solution procedure implements an efficient memory organization technique by proposing a suitable data structure. A heuristic is proposed that achieves significant computational efficiency gains (one to three orders of magnitude improvement over state-of-the-art algorithms) than the exact solution without compromising much on solution quality. The practical application of the algorithm is illustrated in the context of computing the gravity of an edge [14]. This particular application quantifies the importance of an edge relative to others by determining the number of paths passing through it. For this application, it is shown that the proposed method is computationally more efficient than alternative approaches in the literature.

The rest of the paper is organized as follows. The next section provides a review of the related literature. Then, the methodology for the exact label-setting algorithm and the heuristic method is described. The results from the various computational experiments are then presented in Section 4, followed by an application of the proposed algorithm in Section 5. The paper concludes with a summary of the major findings and implications of this study and suggests some promising directions for future research.

2. Review of Related Literature

This section provides an overview of the related literature regarding algorithms for the KSP problem, KSSP problem, and related applications, followed by a summary of gaps.

2.1. KSP Algorithms

The KSP problem has a rich history spanning seven decades, leading to the diverse solution methods listed below. Ref. [15] proposed a brute-force approach enumerating and ranking all paths between a given origin–destination (OD) pair. This method suffers from exponential worst-case complexity and is limited to smaller networks. Ref. [16] introduced the first path deviation-based algorithm using a shortest path tree representation superimposed on the network. Storing several candidate paths is a potential setback of this method, especially on large networks. This method was later adapted by [17], using a dynamic programming approach for KSP to a single destination from all origins.

Shier proposed labeling algorithms [18,19,20] to find KSP from a single origin to all destinations that fall under two categories—label-correcting and label-setting—that primarily differ in the order of processing the network links. Comparing the computational performance of the labeling algorithms for KSP, Ref. [20] found label-setting to be efficient on low-density sparse networks such as transportation and communication networks. The worst-case time complexity of Shier’s labeling approaches, as given by [21], is $O\left(k^2{n}^2\log n\right)$, where $n$ is the number of nodes in the network. As an extension of Gallo and Pallottino’s [22] single origin to all destinations algorithm, Ref. [23] proposed several label-correcting algorithms differing in their node selection strategies. They also note that label-setting has a better worst-case complexity among the labeling algorithms for the KSP problem.

Another approach was developed by [21], which is a path deletion procedure that modifies the network at each iteration to find the next shortest path by removing the current path from the network and re-running any efficient shortest path algorithm. A significant limitation of this approach is that the network size grows with the number of paths to be found. Azevedo et al. [24,25,26] improved this approach to limit the network size and require only a single application of a shortest path algorithm. Ref. [27] came up with a better way of network modification to improve the practical performance of the path deletion algorithm [21], yielding a computational complexity of $O\left(m+kn\log n\right)$.

Ref. [4] proposed an algorithm with the best worst-case complexity on directed graphs with non-negative link costs, maintaining shortest paths in a heap with a time complexity of $O\left(m+n\log n+k\log k\right)$ for a single OD pair and $O\left(m+n\log n+kn\log k\right)$ for a single origin to all destinations. However, the algorithm does not explicitly output the paths themselves. The path lengths can be obtained in a constant time per path, but listing the links along the path requires an additional $O\left(m\right)$ time per path.

2.2. KSSP Algorithms

KSSP applications span diverse domains, including transit routing with scheduled networks [28,29], autonomous vehicle routing [8], and on-the-fly pathfinding in multi-story buildings [30]. Extensive research has addressed efficient heuristics and algorithms for KSSP in directed graphs, particularly for single-destination scenarios. These approaches leverage the cost function structure or network topology.

One of the earliest algorithms for KSSP was proposed by [31] for networks without negative link costs. It involves the repeated application of a single shortest path algorithm where links on the first shortest path are ignored sequentially, one at a time, to find the second shortest path. The minimum of all such paths gives the second shortest path. The $k$th simple shortest path is obtained through the recursive application of this procedure. The path deviation-based method of [16] was modified by [32] to address the constrained case of finding only simple paths on networks with positive link costs.

An attempt for a labeling method for finding $k$ simple shortest paths was made by [33] by modifying Shier’s label-setting algorithm [20]. While Leo’s method guarantees pathwise order and avoids loops, it violates conditions (explained in the following section) necessary for exact solutions. Briefly, the conditions are to find paths in a non-decreasing order of path costs and not to restrict the number of labels maintained for any node. By fixing the number of labels to $k$ for each node and finding the $i$th shortest path to each node before the $i+1$th shortest path to any node, this label-setting method may not always find the optimal paths. The authors in [34] further illustrate this limitation by proving the theorem “It may exist a $k$th shortest loopless path containing a $j$th loopless subpath with $j>k$” using an example network.

Yen’s path deviation-based algorithm [5] boasts the best theoretical worst-case complexity $\left(O\left(kn\left(m+n\log n\right)\right)\right)$ for unrestricted KSSP problems. However, faster algorithms have emerged recently. Gotthilf and Lewenstein’s algorithm [10] targets non-negatively weighted sparse graphs, offering a worst-case complexity of $O\left(k\left(mn+n^2\log \left(\log n\right)\right)\right)$ through replacement paths. Ref. [35] proposed a similar approach with an optimistic case speedup of $\theta \left(n\right)$, but with potential failures in specific graphs.

Ref. [11] improved Yen’s algorithm using a node classification method to reduce the time needed in practice to find new candidate paths on average. Among the fastest practical implementations of KSSP are Kurz and Mutzel’s sidetrack-based algorithm [12] and its proposed improvements by [36], Kadivar’s T* algorithm for acyclic digraphs [37], and Chen et al.’s deviation-based KSP-LPA* algorithm [13]. More recent research includes Casas et al.’s bi-objective path search approach [38], distributed computing of shortest paths [39], and a graph reduction technique [40]. These algorithms, however, are applied to the single-destination KSSP problem by pruning or partitioning the network into smaller subgraphs.

A special case of the multi-destination KSSP has been investigated as a top-k shortest path join problem [41,42]. Based on graph reduction and bounding procedures, these algorithms deal with specific restricted cases. However, they cannot be used when $k$ paths are needed for each node in the subset or for all destinations or when the number of paths is not explicitly known a priori. The worst-case complexity can be the same as Yen’s algorithm. Using relatively small subsets (0.01% to 0.15% of nodes in the network) and a very small number of paths ($k$ = 10 to 50) on test networks, the authors show one to two orders of magnitude computational time improvement in practice than Yen’s algorithm, but the performance with increasing subset size and number of paths is not evaluated.

The KSSP problem has found diverse applications across various domains. Ref. [43] leveraged the $k$ shortest path framework in computer vision to effectively track players in sports video analysis. Routing applications, including public transit routing with transfer penalties and alternate route choices [29] and autonomous driving decision-making under dynamic traffic scenarios [8], often benefit from KSSP formulations. Ref. [30] explored the use of $k$ feasible paths for navigation within large multi-story buildings, demonstrating the utility of KSSP in addressing complex spatial challenges. Another similar problem to KSSP is finding the set of reasonably dissimilar alternative paths on time-dependent networks which are useful in the context of route planning [44], where, in addition to the length/travel time of the paths, their degree of similarity is considered for “meaningful” alternatives. “Terminal paths”, introduced in [45], is a related concept that is also a set of multiple simple paths to several destinations. While the terminal path set does not consider the length of the paths or the size of the set, the multi-destination KSSP problem differs from it in terms of the objective, which is to minimize the path lengths and find a given number of simple paths to each destination.

Analysis of the literature reveals many different algorithms for KSP problems, dominated by deviation/replacement path types for KSSP problems. Previous studies have primarily focused on algorithms for single-origin-to-single-destination scenarios despite several practical applications that could benefit from an efficient single-origin-to-multiple-destinations algorithm. Among the existing studies, compared to the popularity of deviation-based and path-replacement algorithms for KSP and KSSP, the literature on label-setting algorithms is comparatively sparse. This could be attributed to the fact that while the existing label-setting algorithms can solve the KSP problem exactly, they cannot guarantee optimality for the KSSP problem since the optimality principle underpinning general labeling procedures fails for the KSSP problem. Thus, in contrast to labeling algorithms, existing deviation/replacement path type KSSP algorithms designed primarily for a single OD case need to be run for each OD pair separately and do not take advantage of the paths found to other destinations in the earlier runs. Among the labeling methods, as noted by [23], label-setting methods have a better worst-case complexity than label-correcting methods. This gap presents an opportunity to explore label-setting algorithms for potential computational efficiency gains for the multi-destination KSSP problem.

3. Methodology

Let $G\left(N,A\right)$ be a directed network with a set of nodes $N=\left\{\mathrm{1,2},3,\dots ,n\right\}$ and a set of links $A=\left\{\mathrm{1,2},3,\dots ,m\right\}$ such that the number of nodes and number of links are $n$ and $m$, respectively. Links in $A$ are ordered tuples of nodes such that $A\subset N\times N$. A directed simple path from node $s\in N$ to node $t\in N$ is defined as a sequence of nodes ${\gamma }_{s,t}=\left(u_1=s,u_2,\dots ,u_r=t\right)$ with $\left(u_l,u_{l+1}\right)\in A \forall 0\le l<r$, and every node along the path is visited exactly once, i.e., $u_l\ne u_p \forall 0\le l<p\le r$. Let $C_{i,j}$ be the cost of the link $\left(i,j\right)\in A$. The link costs are assumed to be non-negative, i.e., $C_{i,j}\ge 0 \forall \left(i,j\right)\in A$. The cost of the path ${\gamma }_{s,t}$, $C\left({\gamma }_{s,t}\right)$, is defined as the sum of the cost of its constituent links such that $C\left({\gamma }_{s,t}\right)=\sum _{\left(i,j\right)\in A}{C}_{i,j}{\delta }_{i,j}^{{\gamma }_{s,t}}$, where ${\delta }_{i,j}^{{\gamma }_{s,t}}=1$ if link $(i,j)$ belongs to the simple path ${\gamma }_{s,t}$ and 0 otherwise.

3.1. Multi-Destination k Simple Shortest Paths—Problem Definition

The KSSP problem is formally defined here, beginning with the typical case of a single origin to a single destination, followed by the single origin to multiple destinations case and its variants, which are of interest in this work.

3.1.1. Single Destination KSSP

Given a directed network $G\left(N,A\right)$, an origin $s\in N$, and a destination $t\in N$, find the set of simple shortest paths ${\mathsf{\Phi }}_{st}$ from $s$ to $t$, if they exist, such that $C\left({\gamma }_{s,t}\right)\le C\left({\gamma }_{s,t}^{\prime }\right) \forall {\gamma }_{s,t}\in {\mathsf{\Phi }}_{st} , \forall {\gamma }_{s,t}^{\prime }\notin {\mathsf{\Phi }}_{st}$. The number of paths in the shortest path set may be $k$ or fewer. If at least $k$ simple paths exist between $s$ and $t$, the set of interest ${\mathsf{\Phi }}_{st}$ contains exactly $k$ paths, i.e., the cardinality of the set $\left|{\mathsf{\Phi }}_{st}\right|=k$. If fewer than $k$ simple paths exist between $s$ and $t$, then the set of interest ${\mathsf{\Phi }}_{st}$ contains the available number of simple paths, i.e., $\left|{\mathsf{\Phi }}_{st}\right|<k$.

3.1.2. Multi-Destination KSSP

Let $G\left(N,A\right)$ be a directed network. The objective of multi-destination KSSP is to find the sets of simple shortest paths from the origin $s\in N$, ${\mathsf{\Phi }}_{si} \forall i\in N \backslash \left\{s\right\}$, if they exist, such that $C\left({\gamma }_{s,i}\right)\le C\left({\gamma }_{s,i}^{\prime }\right), \forall {\gamma }_{s,i}\in {\mathsf{\Phi }}_{si}, \forall {\gamma }_{s,i}^{\prime }\notin {\mathsf{\Phi }}_{si}, \forall i\in N \backslash \left\{s\right\}$. As explained in Section 3.1.1, it is to be noted that $\left|{\mathsf{\Phi }}_{si}\right|=k$ if $k$ simple paths exist between $s$ and $i$. Otherwise, $\left|{\mathsf{\Phi }}_{si}\right|<k$.

Henceforth, this problem will be referred to as the one-to-all KSSP (KSSP-OA) problem. In addition to this, the KSSP problem class also comprises two other important variants discussed below.

(i) 

One-to-Many KSSP (KSSP-OM)

The objective is to find $k$ simple shortest paths from one origin to every node from a set of destinations $D$. Given a directed network $G\left(N,A\right)$ and an origin $s\in N$, find the sets of simple shortest paths ${\mathsf{\Phi }}_{si}$ from $s$ to each node $i\in D\subset N \backslash \left\{s\right\}$, if they exist, such that $C\left({\gamma }_{s,i}\right)\le C\left({\gamma }_{s,i}^{\prime }\right), \forall {\gamma }_{s,i}\in {\mathsf{\Phi }}_{si}, \forall {\gamma }_{s,i}^{\prime }\notin {\mathsf{\Phi }}_{si}, \forall i\in D\subset N \backslash \left\{s\right\}$. As explained in Section 3.1.1, it is to be noted that the cardinality of the set ${\mathsf{\Phi }}_{si}$ can be $k$ or less.

(ii) 

One-to-All Cost Constrained Simple Shortest Paths (CCSSP-OA)

The objective here is to find all the simple shortest paths from a given origin to any possible destination that are within a cost budget $\alpha$. Given a directed network $G\left(N,A\right)$, an origin $s\in N$, and a cost budget $\alpha$, find the set of simple shortest paths ${\mathsf{\Phi }}_S$ from $s$ to any node $i\in N \backslash \left\{s\right\}$, if it exists, such that $C\left({\gamma }_{s,i}\right)\le \alpha \forall {\gamma }_{s,i}\in {\mathsf{\Phi }}_s$ and $C\left({\gamma }_{s,i}^{\prime }\right)>\alpha \forall {\gamma }_{s,i}^{\prime }\notin {\mathsf{\Phi }}_s$. This problem involves variable $k$ as well as a variable number of destinations to be determined as the output.

3.2. Label-Setting KSSP Algorithm

In the label-setting algorithm, a node’s label $d_i^k$ represents the $k$th simple shortest path from a pre-specified origin node $s$ to node $i$ and comprises three components: the predecessor node ($d_{i,1}^k$), predecessor node’s label index ($d_{i,2}^k$), and cost of the path ($d_{i,3}^k$). At any iteration of the algorithm, each node label belongs to one of two sets, namely, $P$ and $T$. $P$ is a set of permanent labels whose components are guaranteed not to change subsequently. $T$ is a set of temporary labels where one or more of a label’s components may change in further iterations of the algorithm. Let $l_i$ be an index for the number of labels created for node $i$ and $p_i$ be the number of permanent labels for node $i$.

First, the algorithm, proof of correctness and complexity analysis for the KSSP-OA problem are presented, and then the solution procedure for the rest of the variants is provided. In the proposed labeling approach for finding shortest paths, Bellman’s principle of optimality [46], also known as triangle inequality, is preserved by iteratively updating the labels that violate it. The algorithm begins with a single temporary label representing a trivial path to reach the origin $s$ (from itself with zero cost). In each iteration, the temporary label with the least cost among all nodes is made permanent (the rationale is discussed later). The adjacent nodes are then explored, creating new temporary labels (i.e., new paths to those adjacent nodes), provided they are acyclic. The algorithm terminates when all the created labels are made permanent, i.e., all simple paths from $s$ in the network are enumerated, or $k$ best simple paths are found and permanently labeled for each destination. The pseudocode for the label-setting KSSP algorithm is given below as Algorithm 1.

Algorithm 1. Exact_KSSP($G\left(N,A\right)$, $s$) $\to$ $P$
Input: The network instance $G(N,A)$ and origin $s$ Output: The set of $k$ simple shortest path labels $P$
1		// Create a label $d_s^1$ corresponding to the first path to the origin $s$
2		$d_{s,1}^1\leftarrow s$
3		$d_{s,2}^1\leftarrow NULL$
4		$d_{s,3}^1\leftarrow 0$
5		// Create a temporary set $T$ and move $d_s^1$ into $T$
6		$T\leftarrow \varnothing$
7		$T\leftarrow T\cup \left\{d_s^1\right\}$
8		// Create an empty permanent set $P$
9		$P\leftarrow \varnothing$
10		// Initialize the label index and permanent label index for each node
11		$l_s\leftarrow 1$
12		$l_i\leftarrow 0,\forall i\in N \backslash \left\{s\right\}$
13		$p_i\leftarrow 0,\forall i\in N$
14	Repeat
29	Until $T$ is $\varnothing$ or $p_i\ge k \forall i\in N \backslash \left\{s\right\}$ // No more temporary labels to process or at least k permanent labels to every destination are found

The cycle check in line 21 of Algorithm 1 follows the procedure in Algorithm 2 below.

Algorithm 2. CycleCheck($s$, $u$, $p_u$, $v$) $\to$ TRUE/FALSE
Input: $s$, $u$, $p_u$, $v$ // Label pu of node u is the latest permanent label, v is an adjacent node to u, and s is the source Output: A Boolean value // True if v forms a cycle with pu and false otherwise
1		$index\leftarrow p_u$
2		$i\leftarrow u$
3		While $i\ne s$ do
			// Backtrack from the end of the path to the origin. Return TRUE if v already exists and FALSE otherwise
4			If $i==v$
5				Return $TRUE$
6			Else
7				$j\leftarrow i$
8				$i\leftarrow d_{j,1}^{index}$
9				$index\leftarrow d_{j,2}^{index}$
10		Return $FALSE$

Proposition 1. 

In the optimal KSSP solution, for any node, the minimum number of labels created is at least $k$, and in the worst case, the maximum number of labels created is $O\left(\left(n-2\right)!\right)$.

Proof. 

Assuming that at least $k$ simple paths exist from the origin $s$ to an arbitrary node $p$, and since one label is required to represent one distinct path, it is evident that the minimum number of labels to be created for $p$ is $k$.

However, in some cases, the first $k$ labels may not be sufficient. We prove this claim by contradiction. Let us assume that limiting the number of labels created for each node $i$ ($l_i$) to $k$ is sufficient to ensure the correctness of the KSSP solution. Consider two arbitrary nodes, $p$ and $q$, in a network with non-negative link costs where KSSP from origin $s$ is to be found. Suppose the $k$th simple shortest path to $q$ is as follows.

$$d_s^1\to \cdots \to d_p^r\to \cdots \to d_q^k,\left(r>k\right)$$

The above path to $q$ comprises the $r$th simple shortest path to $p$ as a subpath such that $r>k$. This is possible because the subpath optimality does not hold for the KSSP problem. In order for $d_q^k$ to be found, $d_p^r$ should have been found and made permanent earlier. So, when $d_q^k$ is made permanent (i.e., $p_q=k$), the following should hold:

$$p_p\ge r$$

However, since $l_i$ is restricted to $k<r$ for each node $i$, $p_p<r$, in which case, $d_q^k$ is not guaranteed to be optimal. This contradicts our assumption that limiting $l_i$ to $k$ $\forall i$ will ensure the correctness of the solution. As $p$ and $q$ are arbitrarily chosen, we must allow for more than $k$ labels per node to accommodate scenarios where $j>k$ subpaths are necessary for finding the $k$ optimal simple paths to a node.

Lastly, we show that in the worst case, the maximum number of labels that can be created for a node is bounded by $O(\left(n-2\right)!)$. The maximum number of labels that can be created for a destination node $t$ depends on the number of simple paths available to it from $s$. As the worst case, consider a complete graph where every node is directly connected to every other node. The number of paths with no intermediate nodes between origin $s$ and destination $t$ is $1={\displaystyle \frac{\left(n-2\right)!}{\left(n-2\right)!}}$ (i.e., the path $s\to t$). The number of paths with 1 intermediate node is $n-2={\displaystyle \frac{\left(n-2\right)!}{\left(n-3\right)!}}$ (i.e., $n-2$ choices for the intermediate node other than $s$ and $t$). The number of paths with 2 intermediate nodes is ${\displaystyle \frac{\left(n-2\right)!}{\left(n-4\right)!}}$ and so on. Finally, the number of paths with a maximum of $n-2$ intermediate nodes is ${\displaystyle \frac{\left(n-2\right)!}{1!}}$.

Therefore, the total number of simple paths available between $s$ and $t$ is:

$${\displaystyle \frac{\left(n-2\right)!}{\left(n-2\right)!}}+{\displaystyle \frac{\left(n-2\right)!}{\left(n-3\right)!}}+\cdots +{\displaystyle \frac{\left(n-2\right)!}{1!}}={\sum }_{i=1}^{n-2}\left(\left(n-2\right)!\right)\left({\displaystyle \frac{1}{i!}}\right)<\left(n-2\right)!e=O\left(\left(n-2\right)!\right).$$

 □

Theorem 1. 

The proposed label-setting algorithm produces an optimal solution to the KSSP problem at termination, if it exists.

Proof. 

The correctness of the label-setting algorithm is proved through the following hypotheses.□

Hypothesis 1. 

Selecting the smallest temporary label $d_u^{p_u+1}$ from $T$ and making it permanent will ensure optimality.

Hypothesis 2. 

The temporary label $d_u^{p_u+1}$ to node  $u$ in  $T$ represents the smallest label of all simple paths made up of subpaths belonging only to  $P$.

First, we prove Hypothesis 1, assuming Hypothesis 2 holds. Let $d_u^{p_u+1}$ be the smallest temporary label in $T$. This implies $d_{u,3}^{p_u+1}\le d_{i,3}^{p_i+1}\forall d_i^{p_i+1}\in \mathrm{T}$. Also, it corresponds to a simple path ensured by the cycle check performed in line 21. Suppose there is a better $p_{u+1}$th simple shortest path from the origin $s$ to node $u$ composed of some label $d_i^{p_i+1}\in T$. Then, $d_{u,3}^{p_u+1,new}=d_{i,3}^{p_i+1}+C_{i,u}$. $C_{i,u}$ is non-negative and $d_{i,3}^{p_i+1}\ge d_{u,3}^{p_u+1}$. Therefore, $d_{u,3}^{p_u+1,new}\ge d_{u,3}^{p_u+1}$ and is not better than $d_{u,3}^{p_u+1}$. So, $d_u^{p_u+1}$ must be optimal. Hence, the $p_{u+1}$th simple shortest path to $u$ need not be composed of any other label in $T$. By Hypothesis 2, the current smallest label $d_u^{p_u+1}$ in $T$ is optimal among paths made up of labels only in $P$. Thus, selecting the smallest temporary label $d_u^{p_u+1}$ from $T$ and making it permanent will ensure optimality.

Next, we prove Hypothesis 2, provided Hypothesis 1 holds. Let us assume that Hypothesis 2 is true before the label $d_u^{p_u+1}$ from $T$ is moved to $P$. We need to prove that it holds after moving the label (lines 16–17) and arc processing update (lines 22–26). Consider an arbitrary label in $T$, say $d_i^{p_i+1}$. To show: $d_{i,3}^{p_i+1}$ is the optimal $p_{i+1}$th distance from $s$ to $i$ among the labels in $P\cup d_u^{p_u+1}$. Before the update, $d_i^{p_i+1}$ is the shortest $p_{i+1}$th label to $i$ among paths made up of those labels in $P$ (induction hypothesis). The $p_{i+1}$th optimal path from $s$ to $i$ made up of labels in $P\cup d_u^{p_u+1}$ either contains the link $(u, i)$ or does not contain the link $(u, i)$. If it does not contain the link $(u, i)$, then the label $d_i^{p_i+1}$ satisfies Hypothesis 2. If the $p_{i+1}$th optimal path from $s$ to $i$ made up of labels in $P\cup d_u^{p_u+1}$ contains the link $(u, i)$, then the arc processing update implies that a new label $d_{i,3}^j=d_u^{p_u+1}+C_{u, i}<d_{i,3}^{p_i+1}$ is created and inserted in the sorted order so that $j=p_{i+1}$. Thus, the arc processing update ensures that Hypothesis 2 is satisfied for the $d_i^{p_i+1}$th label in $T$. The $d_i^{p_i+1}$th label is arbitrarily chosen. So, the hypothesis is true for all labels in $T$.

Therefore, by making the smallest label in $T$ permanent, followed by the arc processing updates in each iteration, the label-setting algorithm produces the optimal solution. □

Remark 1.

The proposed label-setting algorithm will enumerate simple paths from the origin in a non-decreasing order of path cost.

Proposition 2.

The label-setting algorithm terminates in a finite number of iterations.

Proof. 

The number of nodes in the network and the number of simple paths from origin $s$ to any node are finite. Let the maximum number of simple paths to any node be $k^{\prime }$. Therefore, the maximum size of the set $T$ is finite ($\left|T\right|\le n{k}^{\prime }$), and the algorithm terminates in at most $nk\prime$ iterations. Detailed proof is available in Appendix A. □

Proposition 3. 

The worst-case time complexity of the label-setting algorithm is pseudo-polynomial.

Proof. 

The algorithm can be broken down into four major parts and analyzed separately.

Initialization—Lines 1–11 are constant time operations and can be completed in $O\left(1\right)$ time. Lines 12–13 take $O\left(n\right)$ time to initialize the label indices for the nodes in the network.

Node selection—Let us assume that $T$ is implemented using a sorted list. The minimum cost label in line 15 can be found in $O\left(1\right)$ time. From Proposition 2, the maximum number of temporary labels created is $n{k}^{\prime }$, and in the worst case, line 15 is executed $O\left(n{k}^{\prime }\right)$ times. Moving the minimum cost label from $T$ to $P$ and incrementing the permanent label index (lines 16–19) finishes in $O\left(1\right)$ time.

Arc processing: The loop in line 20, in the worst case, executes $O\left(m{k}^{\prime }\right)$ times. The cycle check in line 21 takes $O\left(n\right)$ time. A temporary label can be created in $O\left(1\right)$ time (lines 22–25). Insertion of a new label into $T$ takes $O\left(n{k}^{\prime }\right)$ (the maximum size of $T$) time (line 26). The total complexity of the loop from lines 20 to 28 is $O\left(m{k}^{\prime }\left(n+n{k}^{\prime }\right)\right)$.

Termination check: the check for termination conditions in line 29 takes $O\left(n\right)$ time.

Thus, the overall time complexity of the algorithm is $O\left(mn{k}^{\prime 2}\right)$ using a sorted list for the temporary labels. It reduces to $O\left(m{k}^{\prime }\left(n+\log k^{\prime }\right)\right)$ using a min heap (see Section 3.4). A detailed analysis is provided in Appendix A. □

The label-setting algorithm is highly flexible and can be readily adapted for solving each of the variants of the KSSP problem defined earlier through suitable modifications to the termination condition (line 29) as per

Table 1. Termination conditions of the label-setting algorithm for the multi-destination KSSP problems.

Problem Variant	Termination Condition	Remark
KSSP-OA	$T$ is $\varnothing$ or $p_i\ge k \forall i\in N \backslash \left\{s\right\}$	No more temporary labels to process or at least $k$ permanent labels to every destination are found
KSSP-OM	$T$ is $\varnothing$ or $p_i\ge k \forall i\in D$	No more temporary labels to process or at least $k$ permanent labels to each destination $i$ in $D$ are found
CCSSP-OA	$T$ is $\varnothing$ or $d_{u,3}^{p_u}>\alpha$	No more temporary labels to process or the cost of the permanent label in the latest iteration to some node $u$ exceeds $\alpha$

. For all the problems, the algorithm must terminate when there are no more temporary labels to process (i.e., $T$ is $\varnothing$). But it can also terminate early when all the required paths are found. For the KSSP-OA problem, this is when $k$ permanent labels are found to each destination node $i$ (i.e., $p_i\ge k$). For the KSSP-OM problem, the algorithm can stop earlier than the KSSP-OA problem since there are fewer destinations considered. In the case of the CCSSP-OA problem, the algorithm can stop if all paths, whose cost is less than or equal to the given budget $\alpha$, are found (i.e., when the cost of the next permanent label is greater than $\alpha$).

3.3. Heuristic Approach

As shown in the complexity analysis, the number of labels is not limited to $k$ but, in the worst case, could grow exponentially due to the presence of cycles in between. This study circumvents this issue by proposing a heuristic method that limits the number of labels created for each node to $k$. This heuristic improves the time complexity of the algorithm and makes it strongly polynomial with a worst-case complexity of $O\left(mn{k}^2\right)$, but it does so by sacrificing accuracy, as it violates Proposition 1. The idea of limiting the labels in the heuristic draws its inspiration from the graph reduction technique [47]. The graph reduction approach is a related concept applied in the single-destination case where the network size is reduced to limit the search space for efficiency gain. While we cannot reduce the network size in the multi-destination case since we need to find paths to each destination, the proposed heuristic achieves efficiency gain by limiting the number of labels without modifying the network. The tradeoff between the gain in computational efficiency and the loss in accuracy is analyzed later in the paper.

The pseudocode for the heuristic approach is given below as Algorithm 3 (the maximum number of labels created for any node is limited to $k$ by replacing lines 20–28 of Algorithm 1 with lines 20–37 of Algorithm 3). Limiting the number of labels also enables other practical improvement strategies. Since not more than $k$ labels are stored for any node, a new label for a node is not added to $T$ unless it is better than the worst of $k$ labels found until then (line 30 of Algorithm 3). Additionally, the cycle check is only performed when the new label is better than the existing labels, as it is expensive. Although these improvements do not change the worst-case complexity, they improve the performance in practice.

Algorithm 3. KSSP_LL($G\left(N,A\right)$, $s$) $\to$ $P$
Input: The network instance $G(N,A)$ and origin $s$ Output: The set of $k$ simple shortest path labels $P$
1		// Create a label $d_s^1$ corresponding to the first path to the origin $s$
2		$d_{s,1}^1\leftarrow s$
3		$d_{s,2}^1\leftarrow NULL$
4		$d_{s,3}^1\leftarrow 0$
5		// Create a temporary set $T$ and move $d_s^1$ into $T$
6		$T\leftarrow \varnothing$
7		$T\leftarrow T\cup \left\{d_s^1\right\}$
8		// Create an empty permanent set $P$
9		$P\leftarrow \varnothing$
10		// Initialize the label index and permanent label index for each node
11		$l_s\leftarrow 1$
12		$l_i\leftarrow 0,\forall i\in N \backslash \left\{s\right\}$
13		$p_i\leftarrow 0,\forall i\in N$
14	Repeat
38	Until $T$ is $\varnothing$ or $p_i\ge k \forall i\in N \backslash \left\{s\right\}$ // No more temporary labels to process or at least k permanent labels to every destination are found

3.4. Data Structures for Scalable Performance

In the heuristic, limiting the number of labels enables some computational enhancements to reduce or avoid some expensive operations from being performed. In Algorithm 1, the temporary labels from all the nodes are maintained together as a single sorted array whose size can be $O\left(nk\right)$. While this structure allows constant time lookups to find the smallest label during node selection, it is inefficient for new label insertion, which occurs frequently during the arc processing step. Therefore, the efficient organization and processing of labels using appropriate data structures could reduce the cost of these operations. Instead of the sorted list, a binary tree structure such as a min heap [48] could be used, which allows constant time lookup for finding the minimum element, and insertions are faster ($O\left(\log nk\right)$) than the sorted list ($O\left(nk\right)$). However, finding the maximum label for each node (line 11 of Algorithm 3) requires looking through all the elements, taking $O\left(nk\right)$ time, which could be improved. Therefore, a two-level organization of the temporary labels at the node (local level) and network (global level) is proposed. The smallest temporary label of each node is kept in the global (network) level partition, and the rest of the temporary labels of each node are kept in their corresponding local (node) level partitions, as illustrated in Figure 1. Thus, finding the next permanent label involves only the global heap with $n$ elements, whereas insertion is performed in the local heap (unless it is the best or first label to a node) with $k$ elements instead of $nk$ elements in the single heap.

The two-level implementation of the heap data structure also offers the flexibility of using different data structures at the two levels. For efficient label organization and processing, a min heap (Williams, 1964) is used in the global structure, which involves only the operation finding the minimum element, whereas the local heap needs both min and max operations. Hence, a min–max heap structure (Atkinson, 1986) is used. In the min heap (binary tree), each parent node has a value no larger than its children, whereas, in the min–max heap, elements at even levels (including the root) have values less than or equal to all their descendants (children, grandchildren, etc.). Conversely, elements at odd levels have values greater than all their descendants. Thus, the minimum element is always at the root, and the maximum element is the maximum of the two elements at the first level. The proposed method of partitioning the node labels is similar to the graph partitioning [45], where different vertices are grouped based on some criteria. However, in the proposed approach, the partitioning is carried out on the node labels based on their cost component rather than the nodes themselves.

The pseudocode for the implementation of the heuristic using the proposed data structures is provided in Appendix A and is referred to in the following analysis. This dual heap structure is chosen because the heuristic frequently needs access to the minimum (line 23) and maximum labels (lines 40 and 52) at the local level, and a min–max heap allows both in constant time. The minimum and maximum elements can be read in constant time and updated/removed from the min–max heap in logarithmic time. In each iteration, the heuristic needs access to the minimum label at the global level to make the next permanent label (lines 18 and 19). A min heap allows reading the minimum element in constant time and updating/removing it from the heap in logarithmic time.

Following the steps of Proposition 3, the worst-case complexity of the heuristic with data structure improvement (referred to as KSSP_LL_Heap) can be determined as follows. In initialization, insertion into $T_{global}$ (line 7) takes logarithmic time ($O\left(\log n\right)$) and creating the label indices (lines 14 and 15) takes $O\left(n\right)$ time. So, the initialization takes $O\left(n\right)$ time in total. In node selection, the minimum cost label can be found in constant time (root element of $T_{global}$). Moving the minimum from $T_{global}$ to $P$ (lines 18 and 19) happens in logarithmic time ($O\left(\log n\right)$). Removal from the min–max heap (line 23) and insertion into the min heap (line 24) happen in a logarithmic time of $O\left(\log k\right)$ and $O\left(\log n\right)$, respectively. Since node selection happens at most $nk$ times, the total complexity of this step is $O\left(nk\left(\log k+\log n\right)\right)=O\left(nk\log kn\right)$. The bottleneck in the arc processing loop is the branch from lines 40 to 52. Here, the cycle check (line 41) takes $O\left(n\right)$ time. The removal and insertion operations for the min heap (lines 47 and 48) take $O\left(\log n\right)$ time each. Insertion into the min–max heap (lines 49 and 51) takes $O\left(\log k\right)$ time. Removal from the min–max heap (line 52) also takes $O\left(\log k\right)$ time. As the maximum number of iterations of the loop is $mk$, the total complexity of arc processing is $O\left(mk\left(n+\log k+\log n\right)\right)=O\left(mk\left(n+\log k\right)\right)$. The termination check takes $O\left(n\right)$ time. The overall complexity of the heuristic is $O\left(n+nk\left(\log kn\right)+mk\left(n+\log k\right)\right)=O\left(mk\left(n+\log k\right)\right)$.

Next, the worst-case time complexities of the proposed and state-of-the-art algorithms for the multi-destination KSSP problem under different network structures are compared. The current state-of-the-art worst-case time complexity achieved through $n$ repeated applications of Yen’s KSSP algorithm is $O\left(k{n}^2\left(m+n\log n\right)\right)$ and Gotthlif and Lewenstein’s algorithm is $O\left(k{n}^2\right(m+n\log \left(\log n\right)\left)\right)$. For dense networks where $k$ is $O\left(n\right)$, both have a complexity of $O\left(n^5\right)$, whereas for sparse networks with non-negative costs, the latter is faster ($O\left(n^4\log \left(\log n\right)\right)$).

The worst-case complexity of the exact Algorithm 1 with the proposed two-level label organization is $O\left(m{k}^{\prime }\left(n+\log k^{\prime }\right)\right)$, where $k^{\prime }\ge k$ denotes the maximum number of labels created by the algorithm for any node. As the maximum number of labels created for a node in Algorithm 1, in the worst case, is $k^{\prime }=O\left(2^n\right)$, the worst-case complexity of the exact algorithm is pseudo-polynomial.

Four special cases which are more likely to arise in practice are considered: (1) dense networks with $k\prime =O\left(k\right)$, (2) dense networks with $k\prime =O\left(n^2\right)$, (3) sparse networks with $k\prime =O\left(n^2\right)$, and (4) sparse networks with $k\prime =O\left(n^2\right)$. By using the fact that $m=O\left(n\right)$ for sparse networks and $m=O\left(n^2\right)$ in dense networks and assuming the number of paths of interest is of the same order of magnitude as the number of nodes ($k=O\left(n\right)$), in case 1, the complexity of Algorithm 1 (exact label-setting algorithm) reduces to $O\left(n^4\right)$, which is better than the popular Yen’s algorithm. In case 2, the complexity is $O\left(n^5\right)$, which is the same as the state-of-the-art algorithm. In case 3, the proposed algorithm has a complexity of O(n³), which is faster than the existing algorithm by an order of magnitude. In case 4, the algorithm has a complexity of O(n⁴), which is faster than the state-of-the-art algorithm by $O\left(\log \left(\log n\right)\right)$.

Table 2. Comparison of the worst-case time complexities for the multi-destination KSSP problem under different network structures.

Network Density	Label-Setting Algorithm		Current State-of-the-Art Algorithm
	${\mathit{k}}^{\mathbf{\prime }}=\mathit{\alpha }\mathit{k}$	${\mathit{k}}^{\mathbf{\prime }}=\mathit{O}\left({\mathit{n}}^2\right)$
Dense, $m=O\left(n^2\right)$	$O\left(n^4\right)$	$O\left(n^5\right)$	$O\left(n^5\right)$
Sparse, $m=O\left(n\right)$	$O\left(n^3\right)$	$O\left(n^4\right)$	$O\left(n^4\log n\right)$

Note: $\alpha$ is some constant value, and $k$ is assumed to be $O\left(n\right)$. Yen’s is the state-of-the-art algorithm for dense networks, whereas Gotthilf and Lewenstein’s has the best reported complexity on sparse networks with positive costs.

summarizes these time complexities under different network structures and the number of labels $k^{\prime }$. Thus, it is clear that the proposed label-setting algorithm is theoretically superior in sparse networks and comparable to Yen’s algorithm whenever the number of labels created $k^{\prime }$ is bounded from above by $O\left(n^2\right)$ and the number of paths $k$ of interest is $O\left(n\right)$. The empirical experiments described in the next section using many real-world networks, which are usually sparse, show that this condition typically holds in practice. Besides the computational performance, the results also examine the trade-off in solution quality between the exact algorithm and the heuristic.

4. Computational Experiments

Computational experiments were conducted to evaluate the computational performance and solution quality of the label-setting algorithm and heuristic, as well as to determine the suitable data structures for organizing the node-level and network-level temporary labels.

The algorithm’s generality is demonstrated by its consistent effectiveness across diverse road networks from various geographical locations, encompassing different sizes and $k$ values. The experiments employed five real-world road network datasets: Anaheim (416 nodes, 9145 links) [49], Barcelona (1020 nodes, 2522 links) [49], Rome (3353 nodes, 8870 links) [50], Hessen (4660 nodes, 6674 links) [49], and Austin (7388 nodes, 18,956 links) [49]. Link costs were randomly assigned between 1 and 10 for each network using a uniform distribution. Other non-negative link cost functions, such as the Bureau of Public Roads function, can also be used.

The heuristic’s performance was compared against three algorithms from the literature, namely, Yen’s algorithm (Y) [5], a node classification-based (NC) algorithm by [11], and a sidetrack-based (SB) algorithm using dynamic updates of shortest path trees by [51].

The following metrics were used to evaluate the performance of the algorithms. The computational performance is measured with the average total running time, and the solution quality or accuracy is measured with the average percentage deviation of the $k$th path cost.

• Average total running time: This metric represents the average time, measured in CPU time, taken to find the required paths. This excludes the time spent reading input data and writing output data.
• Average percentage deviation of $k$th path cost: This metric measures the average percentage increase in the $k$th simple shortest path cost obtained by the heuristic algorithm ($c^{*}$) from the exact $k$th simple shortest path cost ($c$). It is calculated as $100\times \left({\displaystyle \frac{c^{*}-c}{c}}\right)\%$, expressing the difference as a percentage of the exact cost.

For each network, the results at different levels of $k$ correspond to the averages obtained from multiple OD pairs.

4.1. Evaluation of Data Structures for Temporary Labels

The computational performance of the algorithm and the heuristic were evaluated for the single destination KSSP problem. First, a naïve implementation was tested where all the temporary labels are maintained in a single level using a sorted list. Then, the proposed two-level organization of temporary labels was tested using four possible combinations of min heap and min–max heap—(i) min heap (global level) and min heap (local level), (ii) min–max heap (global level) and min–max heap (local level), (iii) min heap (global level) and min–max heap (local level), and (iv) min–max heap (global level) and min heap (local level). The average computational time over 50 randomly chosen OD pairs was compared for each network. The experiment was conducted at five different levels of $k$: 100, 500, 1000, 1500, and 2000. A maximum running time threshold of 30 min was used for each instance, and the test was terminated if the running time for an instance exceeded this threshold.

Table 3. Computational performance of the proposed solutions with the temporary labels stored in a sorted list.

Network	Average Running Time for Algorithm 1 (s)				Average Running Time for the Heuristic (Algorithm 3) (s)
	k = 100	k = 500	k = 1000	k = 1500	k = 2000	k = 100	k = 500	k = 1000	k = 1500	k = 2000
Anaheim	4.32 × 102 *	8.90 × 102 *	1.13 × 103 *	1.30 × 103 *	1.38 × 103 *	3.75 × 10−1	8.88	3.38 × 101	7.46 × 101	1.31 × 102
Barcelona	9.86 × 102 *	1.28 × 103 *	1.44 × 103 *	1.57 × 103 *	1.60 × 103 *	2.27	5.56 × 101	2.17 × 102	5.42 × 102	9.91 × 102 *
Rome	1.52 × 103 *	1.66 × 103 *	1.70 × 103 *	1.74 × 103 *	1.74 × 103 *	1.19 × 101	2.70 × 102	1.08 × 103 *	1.46 × 103 *	1.63 × 103 *
Hessen	1.57 × 103 *	1.62 × 103 *	1.64 × 103 *	1.66 × 103 *	1.68 × 103 *	5.79	1.34 × 102	5.25 × 102	1.19 × 103 *	1.51 × 103 *
Austin	1.47 × 103 *	1.58 × 103 *	1.64 × 103 *	1.67 × 103 *	1.70 × 103 *	3.37 × 101	6.59 × 102 *	1.13 × 103 *	1.35 × 103 *	1.47 × 103 *

* A lower bound for the average running time as some instances exceeding the running time threshold were terminated.

presents the computational results for the naïve implementations of Algorithms 1 and 3 using a sorted list. It is important to note that some instances exceeded the 30 min limit, and their running times were capped at the threshold value. Consequently, the average times reported for such cases represent lower bounds rather than exact figures. The results clearly demonstrate the inadequacy of the naïve implementations as the algorithms exhibited execution times in the order of several minutes.

Figure 2 shows that the best performance is obtained when the node-level labels are handled using a min–max heap, and either a min heap or a min–max heap is used to handle the network-level labels, irrespective of the network size and the number of paths. This makes sense intuitively. When examining nodes during each iteration, the algorithm needs to identify the one with the smallest temporary label. Similarly, when exploring the outgoing arcs from a specific node, the node labels are compared to find the largest one. These operations involve the smallest and largest labels at the network and individual node levels, respectively. The run time difference between a min heap and a min–max heap at the network level is negligible, and both structures efficiently provide access to the minimum element. However, since the min–max heap is unwarranted at the network level, a min heap at the network level and a min–max heap at the node level are recommended. This best-performing data structure combination is used for the rest of the experiments.

4.2. Evaluation of the Heuristic’s Performance

The KSSP_LL_Heap method was evaluated against Y, NC, and SB algorithms based on computational time and solution quality. The experiment was conducted with the randomly selected 50 OD pairs for the single destination case and from the origins of the 50 pairs to all destinations in the network for the multi-destination case (KSSP-OA problem). The reported results for each case represent the average over all instances when $k$ was fixed at 100, 500, 1000, 1500, and 2000.

Existing algorithms perform well for a single destination but struggle to scale effectively to multiple destinations. Figure 3 shows the average computational time taken by the algorithms to find KSSP for all destinations. Compared to the single destination case, for the benchmark algorithms, the run times increased by 386 times, 946 times, 3262 times, 3936 times, and 6325 times on average for the Anaheim, Barcelona, Rome, Hessen, and Austin networks, respectively. In contrast, it was only 1.35 times, 1.63 times, 1.76 times, 1.74 times, and 2.64 times for KSSP_LL_Heap.

For multiple destinations, it is clear from Figure 3 that KSSP_LL_Heap outperforms other algorithms in terms of computational time. KSSP_LL_Heap provides a speedup of 29 to 1416 times across the networks and gets better as the network size grows.

While the heuristic does not guarantee an optimal solution, it offers a significant computational advantage at the expense of a slight compromise in solution quality. Figure 4 shows that the quality of the heuristic solution is only marginally worse than the optimal solution across networks and the number of paths found. Moreover, for a given $k$, the solution accuracy is mostly higher for larger networks. The average deviation in the $k$th path cost is at most 0.167% of the actual $k$th path cost. It is also observed that the solution quality improves when the number of paths to be found increases. This finding suggests that one could almost always find the optimal solution with the heuristic by setting $k$ to be larger than needed while still having the computational benefits.

To further understand this tradeoff between speed and accuracy, an experiment was conducted where the number of labels created ($k^{\prime }$) was set to be higher than $k$ (the number of simple paths required). Figure 5 illustrates the speed–accuracy tradeoff as a function of $k^{\prime }$ when $k$ is 100. It is seen that the deviation in the $k$th path cost could be driven towards zero by increasing the number of labels for each node by a certain percentage of $k$. In all cases, the deviations are in the order of 0.004 to 0.147% (i.e., 99.853 to 99.996% accurate). Across all networks, we observed a consistent trend: as $k^{\prime }$ increased, the accuracy improved, while the computational time increased marginally. This trend is particularly evident in the Barcelona network (Figure 5b), where a 15% increase in the number of labels led to a threefold improvement in accuracy.

Similarly, the other networks (Figure 5a–e) saw a twofold accuracy boost with a 20–25% increase in the number of labels used. Notably, these accuracy gains were achieved with minimal increases in computational time across all networks. Empirically, we can expect a unit of extra computational time to buy one to two orders of magnitude increase in accuracy.

5. Illustrative Practical Application

This section demonstrates the usefulness and efficacy of the proposed algorithm for a practical application arising in a network science context. The problem attempts to quantify the significance of edges in a network and rank them based on their structural importance using a measure called Edge Gravity (Helander and McAllister, 2018). The edge gravity or the structural importance of an edge is the number of paths in the network comprising it. This concept is crucial in understanding various social, biological, and transportation networks. For instance, in transportation networks, identifying edges with high edge gravity can reveal critical links that enhance accessibility. Similarly, edge gravity can help find influential individuals in social networks or measure the overall resilience of a network. Through quantifying and ranking connections, it becomes a valuable tool for studying and manipulating social and other types of networks.

The calculation of the metric requires the enumeration of all paths in the network, which can be performed using KSSP_LL_Heap, as finding the KSSP to all destinations (repeated from all origins) will provide all the paths in the network if a sufficiently large value of $k$ is used. In networks where enumerating all paths is not practically feasible, the authors proposed the metric k-Gravity, which is the edge gravity computed using only the top $k$ shortest paths between all OD pairs. The k-Gravity serves as a lower bound of the actual edge gravity. For the path enumeration, [14] adapted a KSP algorithm by running it for each OD pair in the network for an adequately large value of $k$. They emphasized that the choice of the KSP algorithm is crucial for efficiently calculating edge gravity. Since path enumeration is the dominant step in this calculation, improvements in its computation time are necessary to handle larger networks. They state, “Choice of a specific k–shortest path algorithm for enumerating the paths appears to be a factor and presents an interesting set of extension studies. Examination and improvement in computation time for Edge Gravity is necessary to address larger static and single-layer networks, which necessarily prefaces complexity that includes time-evolving and multi-layer networks”.

The current study shows that the path enumeration for the edge gravity computation can be performed more efficiently with the proposed KSSP_LL_Heap, enhancing the scalability of the metric to larger networks. The computational performance is illustrated in

Table 4. Computational performance for obtaining the edge gravity metric.

Network	$\mathit{n}$	$\mathit{m}$	$\mathit{k}$	Total Paths Found	Maximum Path Length	CPU Time Reported by Helander and McAllister (s)	CPU Time for Y (s)	CPU Time for KSSP_LL_Heap (s)
Granovetter ’73 example A	10	42	416	14,796	9	3.17 × 10−2	1.33 × 10−1	2.39 × 10−2
Granovetter ’73 example B	25	82	17,480	2,130,510	24	124.31	94.67	6.51
Sioux Falls	24	76	4787	1,717,464	23	🗴	56.55	4.87
Eastern Massachusetts	74	258	5000 *	5,316,354	18	🗴	1417.08	10.15
Eastern Massachusetts	74	258	10,000 *	10,633,368	20	🗴	3912.52	21.53

* Paths enumerated for the k-Gravity computation. 🗴 These networks were not used by [14].

using Granovetter’s example networks used by the authors in their experiments and two other road networks of Sioux Falls and Eastern Massachusetts [49].

The result shows that KSSP_LL_Heap is much faster on the same networks used by the authors. A 14–20 times speedup is achieved on the Granovetter ’73 example B network. Moreover, the scalability provided by KSSP_LL_Heap is evident from the other networks. On the larger Eastern Massachusetts network, KSSP_LL_Heap calculates the edge gravity using more than 10 million paths in 21.53 s, which is about 182 times faster than algorithm Y. It is clear that the computational benefits provided by KSSP_LL_Heap over existing methods grow with the problem size.

Given that the number of paths present in the Eastern Massachusetts network is huge, the k-Gravity metric was computed considering the practical feasibility. To understand whether the importance of an edge remains stable as more paths are enumerated and get an idea of the quality of the ranking obtained with $k$ values sufficiently large in practice, sensitivity analysis was performed as described below. First, the sensitivity of the absolute k-Gravity value of an edge for different values of $k$ was investigated. For this, the normalized k-Gravity value of an edge is defined as the ratio of its k-Gravity to the total number of paths found between all OD pairs. The variation in the normalized k-Gravity averaged over all the edges in the network is shown in Figure 6. From Figure 6, it is observed that the average normalized k-Gravity value starts to stabilize in the range of $k$ = 10,000 to 20,000 as the rate of increase (slope) in the average normalized edge gravity drops sharply at $k$ = 10,000 and starts converging to a constant value.

Next, the sensitivity of the rank ordering of the edges based on their k-Gravity was analyzed by studying the differences in the rank order of edges obtained with a value of $k$ against that obtained with $k$ = 50,000. With $k$ = 50,000, a large set of paths (approximately 27 million) is obtained, and the corresponding k-Gravity is assumed to provide the actual order of edge importances for the purpose of this analysis. The distribution of the absolute difference in the rank of an edge obtained with a given value of $k$ against the actual order is shown in Figure 7. It is observed that the range of the rank differences continuously reduces from 82 at $k$ = 1000 to 7 at $k$ = 40,000, indicating that the distribution of the rank differences (i.e., the error in ordering) tends to converge towards zero (mean and variance of differences shrink) with increasing $k$. The plot also corroborates that a $k$ value between 10,000 and 20,000 seems to provide a sufficiently good choice for the lower bound of edge gravity since the average absolute rank difference is around 10 for $k$ = 20,000 (0.05% error), which is practically acceptable.

Further, the rank correlation between the edge ranks obtained for $k$ = 10,000 was compared against the upper bound of $k$ = 50,000. Since the relationship between two sets of ranked (ordinal) data is analyzed, appropriate statistical measures of Spearman’s rank correlation coefficient [52] and Kendall’s $\tau$ [53] are used. Spearman’s rank correlation coefficient turned out to be close to 1 (0.98), and Kendall’s $\tau$ was 0.9, and both were statistically significant (p < 1 × 10⁻¹⁰⁰), suggesting the adequacy of using 10,000 paths per OD to estimate edge gravity. This procedure can be adopted for other networks to determine convergence and find the smallest $k$ needed to estimate edge gravity. However, the thresholds for convergence may depend on network topology and connectivity.

These analyses show that k-Gravity with a reasonably higher value of $k$ that is practically feasible can be used to obtain a close enough approximation of the actual edge gravity on larger networks without needing to enumerate all the paths.

6. Conclusions

This study proposes a novel label-setting framework for solving the multi-destination KSSP problem and its variants in directed graphs with non-negative edge weights. The proposed labeling framework obviates the need to repeatedly solve the KSSP problem for each destination as is necessary in path deviation algorithms (such as Yen’s), resulting in a significant speedup of the algorithm. An exact algorithm, which is pseudo-polynomial, and a practically efficient heuristic based on bounded labels and a two-level heap data structure are implemented and evaluated theoretically and using computational experiments on several real-world networks.

An efficient heuristic is developed and implemented by limiting the number of labels for each node to $k$ and designing a two-level heap data structure to store temporary labels. The proposed KSSP_LL_Heap heuristic has a complexity of $O\left(mk\left(n+\log k\right)\right)$, which is polynomial in $k$ and network size, and offers significant computational benefits over state-of-the-art algorithms with a marginal degradation of solution quality. As a result, the worst-case complexity of the heuristic is significantly faster in both sparse and dense networks than existing state-of-the-art algorithms.

Computational experiments on many real-world networks corroborate the findings from the above theoretical complexity analysis. The proposed heuristic provides significant computational speedups from 29 to 1416 times over the state-of-the-art algorithms in real-world networks of varying sizes and $k$ values with negligible loss in accuracy (at most 0.167%). Finally, a practical application of the proposed method is illustrated to determine the gravity of an edge (relative structural importance) in a network.

The multi-destination KSSP offers a robust framework for tackling several applications in the future, including the following: (i) a KSSP-OM approach, incorporating real-time crowding data, can dynamically be used to re-route passengers departing from mass gathering events through less congested alternative paths, minimizing travel time and improving passenger experience and (ii) a CCSSP-OA formulation can be applied to assess the number of travel options available from a specific location within a limited time budget, aiding in the evaluation and promotion of more accessible public transit systems. Extensions to multi-criterion and time-dependent versions are challenging areas for further research.