An Improved Discrete Jaya Algorithm for Shortest Path Problems in Transportation-Related Processes

Abstract

Shortest path problems are encountered in many engineering applications, e.g., intelligent transportation, robot path planning, and smart logistics. The environmental changes as sensed and transmitted via the Internet of Things make the shortest path change frequently, thus posing ever-increasing difficulty for traditional methods to meet the real-time requirements of many applications. Therefore, developing more efficient solutions has become particularly important. This paper presents an improved discrete Jaya algorithm (IDJaya) to solve the shortest path problem. A local search operation is applied to expand the scope of solution exploration and improve solution quality. The time complexity of IDJaya is analyzed. Experiments are carried out on seven real road networks and dense graphs in transportation-related processes. IDJaya is compared with the Dijkstra and ant colony optimization (ACO) algorithms. The results verify the superiority of the IDJaya over its peers. It can thus be well utilized to meet real-time application requirements.

1. Introduction

The shortest path problem (SPP) is among the most fundamental ones in graph theory. It is concerned with finding the shortest path from a specified origin to a destination in a given graph or network. In general, each edge’s distance, time, and price is called cost. This paper uses “cost” to indicate the distance, time, and other physical attributes of a network. It is applied in a variety of domains (both as a stand-alone model and as a subproblem in complex problems), such as transportation [1,2,3], biological networks [4], social networks [5], circuit board layout [6], and robotic search/navigation processes [7,8,9,10,11,12,13]. In recent years, the rapid development of sensing and Internet of Things (IoT) technology has allowed us to obtain environmental changes rapidly [14,15]. Since such changes impact SPP solutions, it becomes increasingly important for us to find SPP solutions efficiently. Efforts are required to develop faster algorithms than traditional and existing ones to solve SPP.

Many classical algorithms and a series of their variants are proposed, e.g., Dijkstra [16,17,18], Bel, Floyd [19,20], Dreyfus [21], and A-Star [22,23], to solve SPP. There are some other ways to solve SPP, such as simple heuristics, meta-heuristics, and neural networks. Otte and Correll (2013) [24] propose a parallel framework of the shortest path planning algorithm based on single-query sampling. Zhang, et al. (2014) [25] propose a novel parameter-free minimum resource neural network framework to solve shortest path problems for various graph types. Jan, et al. (2014) [26] present a method based on Delaunay triangulation, improved Dijkstra algorithm (DA), and Fermat points to construct a new graph that can obtain near-shortest paths in a short computational time. Lei, et al. (2015) [27] propose a parallel field-programmable gate array implementation to solve SPP. An extended systolic array priority queue is proposed to allow large-scale priority queue processing. Wang, et al. (2016) [28] suggest an improved A-star algorithm to solve SPP with position-based learning effects. Huang, et al. (2017) [29] adopt a position-based pruning strategy to reduce the number of node pairs. An algorithm based on point-to-point shortest path calculation is presented to improve efficiency. Li, et al. (2018) [30] designed an efficient shortest-path algorithm that compresses an original network into a small one that preserves the graph properties used to calculate a path. Yang, et al. (2020) [31] present an ant colony algorithm to solve the shortest path problem. Krauss, et al. (2020) [32] propose three different approaches for solving SPP using a quadratic unconstrained binary optimization formulation suitable for development on a quantum annealing machine.

SPP expansions are also widely studied. Examples of other generalizations of SPP are the K-shortest path problem [33], the shortest time path problem with time windows [34], and the traveling salesman problem [35,36,37,38]. The application of the SPP extends to the realm of industrial automation. The SPP has been used to optimize and streamline processes, e.g., the design of mechanical components for automation platforms [39], measurement of industrial robot poses [40], and solution of characteristic equations for the elliptical trajectories of industrial robots [41].

Chen, et al. (2013) [42] present a stochastic travel speed model to express the problem of finding the minimal expected time path in stochastic time-dependent road networks. Feng and Korkmaz (2015) [43] propose a new Lagrangian relaxation algorithm to solve a multi-constrained multiple SPP. Talebi, et al. (2017) [44] study online shortest path routing over multi-hop networks. Chemodanov et al. (2018) [45] propose a novel neighborhood method for a constrained SPP. The neighborhood method uses a search space reduction technique and has a theoretical quadratic speed-up that allows it to reach solutions faster than its peers. Li, et al. (2018) [46] present an index-based A-Star algorithm to solve the SPP in a weighted directed acyclic graph with unknown vertex coordinates. Ganganath, et al. (2018) [47] designed a heuristic search algorithm to find solutions to the shortest path on uneven terrains. Su, et al. (2019) [48] propose a multi-stage meta-heuristic algorithm for solving the SPP with must-pass nodes. Kou, et al. (2019) [49] propose two algorithms for a single-constrained SPP. Jie, et al. (2019) [50] establish an information transmission time expectation-variance shortest path model and a fuzzy shortest path critical edge model. An improved ant colony algorithm with traffic congestion factor and random variables is developed to solve the SPP in an uncertain environment. Binh, et al. (2019) [51] suggest an improved evolutionary algorithm that reduces the search space to overcome massive resource consumption in solving clustered shortest-path tree problems. Liu, et al. (2019) [52] propose an optimal path selection algorithm that applies reinforcement learning strategies and designs a new length-first optimal path selection method based on prior knowledge. Xiong, et al. (2020) [53] present an integer programming model for one-to-one pickup and a delivery problem. Two different splitting strategies are proposed to solve the split demand one-to-one pickup and delivery problem with the shortest-path transport along real-life paths. Krauss and McCollum. (2020) [32] designed three different ways to implement the formula of the SPP on a quantum annealing computer. Thanh, et al. (2021) [54] proposed a new method to solve clustered shortest-path tree problems based on a multifactorial evolutionary algorithm. Cosma, et al. (2021) [55] designed a novel genetic algorithm to solve the clustered shortest path tree problem that defines meaningful genetic operators and uses an initial hybrid population.

Although the SPP is studied extensively, researchers face a challenging task when handling large and complex networks in engineering applications. Its various extension problems, such as k-shortest paths, traveling salesman problems, shortest path with time windows, and multiobjective shortest path, are all NP-hard problems. The SPP is frequently invoked when solving these problems. Reducing the running time of the SPP can greatly improve the efficiency of these algorithms. The proposal of a meta-heuristic algorithm to solve the SPP can be regarded as laying the foundation for solutions to other NP-hard problems involving the SPP. In many specific cases, practitioners just need high-quality paths within a very short time instead of the shortest ones but an unacceptably long time during which any parameter/environmental changes may void an optimal one. In other words, they need the shortest possible time or real-time response to obtain an approximate shortest path. For example, a number of attributes affecting the optimal path in an urban road can change at any time. Such changes require a real-time update of the optimal path. If the guidance is not given quickly, a driver might end up missing an intersection or entering the wrong path. A meta-heuristic algorithm becomes a preferred choice due to its controllable and limited running time and ability to find a high-quality solution [56,57]. The work [58] proposes a simple meta-heuristic algorithm called Jaya to solve continuous optimization problems. Compared with other meta-heuristic algorithms, Jaya is easier to be applied because it does not need to consider complex parameters but just needs to set the number of iterations and population size as its outstanding feature. Jaya is highly competitive in comparison with other heuristic algorithms, e.g., particle swarm optimizer (PSO), genetic algorithm (GA), differential evolution (DE), artificial bee colony (ABC), and teaching-learning-based optimizer (TLBO). It has been extensively used in various fields, such as photovoltaic systems [59], electricity theft detection [60], power transmission [61], unmanned aerial vehicle control [62], manufacturing [63], and scheduling [64,65].

We propose to adopt Jaya to solve the SPP for the first time because of its excellent performance and successful engineering optimization problems. The SPP aims to find the shortest path on a given network that requires connecting discrete points in series and finally giving a set of nodes and their order. It is a discrete problem. The original Jaya algorithm is not suitable for solving discrete problems. Gao, et al. (2016) [57] propose a discrete Jaya algorithm by improving the strategy for new solution generation and applying it to manufacturing process scheduling problems. This work proposes an improved discrete Jaya (IDJaya) algorithm for solving the SPP. Figure 1 shows the flowchart of our proposed method. This work contributes to the field of the SPP by (a) developing a discrete version of Jaya to solve it and a local search operator to improve the performance of the discrete Jaya algorithm (DJaya) and (b) comparing the proposed IDJaya with its peers.

The remainder of this paper is organized as follows. The mathematical model of the SPP is formulated in Section 2. Section 3 introduces the IDJaya to solve the SPP. Section 4 presents the experimental results and their comparisons with their competitive peers. Finally, Section 5 concludes this paper.

2. Problem Description and Mathematic Formulation

In this section, we illustrate our concerned SPP. A network is represented by an undirected and connected graph G = (V, E), where V = {v₁, v₂, …, v_n} represents the set of nodes and E = {e₁, e₂, …, e_m} represents the set of edges. |V| = n and |E| = m represent the total number of nodes and edges in graph G, respectively. An edge between nodes v_a and v_b is denoted by e_ab. Each edge has a cost c_ab (e.g., representing distance, time, or price) that indicates the cost between nodes v_a and v_b. p_od ∈ P is a path connecting origin (v_o) and destination (v_d), where P is the set of paths. The cost of p_od is represented by C_od, which is calculated by summing the costs of each edge in p_od.

Definition 1 (Shortest Path): For a given graph G, the shortest path from v_o to v_d is defined as the path with the smallest C_od.

As shown in Figure 2, there are three alternative paths, i.e., $p_{\mathrm{1,3}}^1$: 1-2-3, $p_{\mathrm{1,3}}^2$: 1-3 and $p_{\mathrm{1,3}}^3$: 1-4-3. Accordingly, $C_{\mathrm{1,3}}^1$ = 7, $C_{\mathrm{1,3}}^2$ = 5 and $C_{\mathrm{1,3}}^3$ = 9. Here, $p_{\mathrm{1,3}}^2$: 1-3 is the shortest path in this network. If there is more than one shortest path between v_o and v_d, p_od is one of them.

We formulate the SPP as follows:

$$\mathrm{Min} p_{od}={\sum }_{e_{ij}\in p_{od},i\ne j}{c}_{ij}$$

(1)

subject to:

$$\begin{gathered} \forall v_k\in V-\{v_o,v_d\}, v_i\in V-\left\{v_d\right\}, v_j\in V-\left\{v_o\right\}, \\ \sum _{v_i,v_j,v_k\in \left\{P\right\},i\ne k}{x}_{ik}-\sum _{v_i,v_j,v_k\in \left\{P\right\},j\ne k}{x}_{kj}=0 \end{gathered}$$

(2)

$$c_{ij}=c_{ji}, \forall v_{i,j}\in V$$

(3)

$${\sum }_{v_i,v_j\in \left\{P\right\},i\ne j}{x}_{ij}\le 1$$

(4)

$$x_{ij}\in \left\{\mathrm{0,1}\right\}, \forall i,j=\{1, 2,\dots ,n\}, i\ne \dot{J}$$

(5)

The objective function (1) serves to minimize path costs. Constraint (2) guarantees network connectivity. (3) restricts that the network is an undirected graph. (4) ensures that each node is accessed at most once, i.e., paths have no loops. (5) defines a binary decision variable.

3. Proposed Solution Approach

As networks become large, classic SPP algorithms fail to handle the SPP. A new discrete Jaya algorithm is thus proposed to solve it. Original Jaya is not suitable for solving the SPP because each node is discrete, and Jaya cannot give a solution with discrete values. We extend Jaya by revising a generation strategy of solutions to address this problem such that the proposed IDJaya can access nodes in a network to generate candidate solutions (paths).

3.1. Original Jaya Algorithm

Jaya is a novel and simple algorithm. It produces new solutions and constantly tries to find the solutions closer to the optimal solution but away from the worst one. Note that “Jaya” means victory in Sanskrit. Its performance relies on only two parameters, i.e., the number of iterations and population size. It can be viewed as being parameter-free when compared with other popular nature-inspired algorithms such as PSO and ACO. Its simplicity makes it convenient to implement in any programming language, and it is also easy to convert codes between different programming languages. It has the following steps according to [58]:

1. Initializing the population size (K), termination condition (i.e., number of iterations), and number of decision variables.

2. Finding the best and worst solutions in population.

3. Generating new solutions via:

$${Y }_{j,k,i}^{\prime }=Y_{j,k,i}+R_1\left(Y_{j,best,i}-\left|Y_{j,k,i}\right|\right)-R_2(Y_{j,worst,i}-\left|Y_{j,k,i}\right|)$$

(6)

4. If the new solution is superior to the best solution, then replace the latter with the former.

5. Comparing original solutions with new ones and saving top K results.

6. Determining whether a pre-given termination condition is met. If so, output results. Otherwise, repeat Steps 2–6.

3.2. Discrete Jaya Algorithm for SPP

Jaya is proposed to solve a continuous optimization problem. Since the SSP is discrete, we have to design a new solution generation strategy to make Jaya suitable for the SPP. Therefore, a discrete Jaya algorithm (DJaya) for solving the SPP is proposed. An additional term that can randomly generate adjacent nodes is added to increase the exploration ability of DJaya, called IDJaya. The difference between IDJaya and DJaya is that IDJaya adds a local search algorithm to improve its solution accuracy. Due to the particularity of the SPP, a newly produced node may not be in an original path, and parameters ${\tilde{\phi }}_{j,k,i}$/${\check{\phi }}_{j,k,i}$/${\widehat{\phi }}_{j,k,i}$ are thus added to ensure the connectivity of the generated paths. IDJaya generates a set of points and builds a path as follows:

$$v_{j,k,i}^{\prime }={{\tilde{\phi }}_{j,k,i}r}_1{v}_{j,k,i}+{{\check{\phi }}_{j,best,i}r}_2{v}_{j,best,i}+{{\widehat{\phi }}_{j,worst,i}r}_3{v}_{j,worst,i}+{r_{4}v}_{j,random,i}$$

(7)

$$\{v_{j,k,i}^{\prime }{\}\to p}_k^{\prime }$$

(8)

$$r_1,r_2,r_3,r_4 \in \{\mathrm{0,1}\}\cap \sum _{j=1}^4{r}_j=1$$

(9)

where r_i is a binary random number taking 0 or 1 at random and satisfying that only one of them be 1, implying that only one of them is selected to produce a new node; ${\tilde{\phi }}_{j,k,i}$, ${\check{\phi }}_{j,k,i}$ and ${\widehat{\phi }}_{j,k,i}$ are introduced to prevent IDJaya from being unable to continue running since newly generated nodes are not in the paths. They are used to determine whether the node is in the initial path, best path, and worst path, respectively. They are binary decision variables. ${\tilde{\phi }}_{j,k,i}$ = 1 when the node can be found in the initial path, and otherwise zero. So are ${\check{\phi }}_{j,k,i}$ and ${\widehat{\phi }}_{j,k,i}$. For example, a newly generated node is 6. Assuming that the initial path and best path contain node 6, we have: ${\tilde{\phi }}_{j,k,i}$ = ${\check{\phi }}_{j,k,i}$ = 1 and ${\widehat{\phi }}_{j,k,i}$ = 0. $v_{j,k,i}^{\prime }$ is a newly generated node and $v_{j,k,i}$ is an alternative one that is the next node on the selected path. $v_{j,best,i}$ and $v_{j,worst,i}$ represent the next node on the best and worst paths, respectively. $v_{j,random,i}$ includes all nodes accessible by the previous point (except the points that are already in the path). We later give a simple example to show how it works.

Unlike Jaya’s solution generation strategy, (7) generates a node in a new path instead of a complete solution. It is constantly called until a new complete path is generated from the origin to the destination. These newly generated nodes build a new path, as shown in (8). The remaining process of the IDJaya is the same as that of the original Jaya. Figure 3 shows the flowchart of IDJaya.

IDJaya requires initial solutions for operation. Initial solutions refer to random paths between an origin to a destination. In order to overcome the difficulty of initial path acquisition in large networks, we propose a random path generation method based on orientation. It always visits a new point in the same direction toward the destination to ensure that a random path can be found quickly.

The idea of our algorithm is based on Jaya. We propose a new solution generation strategy such that Jaya can solve the path problems. A node in a new path is generated when the strategy is invoked. (7) is repeatedly used until the destination is visited and a new path is produced. Its complete procedure is described in pseudo-code of IDJaya with the following steps: (1) set parameters, i.e., population size and the number of iterations; (2) calculate the cost of initial paths and find out the best and worst solutions; (3) select a path in sequence and generate a new point according to Step 6; (4) repeat steps 5–7 until the destination is visited, thus resulting in a new path; (5) use this method to produce corresponding new paths for all initial ones; (6) call the local search algorithm to generate new solutions; (7) compare all paths and select the top K optimal solutions as the latest path group. (8) repeat the above steps until termination conditions are met, i.e., the maximum number of iterations is reached.; (9) output a path with the lowest cost. {R_k} is a set of paths that is constantly being updated as the algorithm is executed (Algorithm 1).

Algorithm 1. Improved discrete Jaya for shortest path problems (IDJaya)

Input: Origin O, Destination D, Road network G, Population size K, Maximal iteration count $\widehat{I}$     Output: The shortest path 1.   Calculate {COD} 2.   Obtain the best value of C (i.e., (COD)best) and the worst value of C (i.e., (COD)worst) 3.   $\mathrm{for} i=1 \mathrm{to} \widehat{I}$ 4.     for k = 1 to K 5.         for j = 1 to c 6.               $v_{j,k,i}^{\prime }={{\tilde{\phi }}_{j,k,i}r}_1{v}_{j,k,i}+{{\check{\phi }}_{j,best,i}r}_2{v}_{j,best,i}+{{\widehat{\phi }}_{j,worst,i}r}_3{v}_{j,worst,i}+{r_{4}v}_{j,random,i}$ 7.         end for 8.                 $R_k^{\prime }$ ←$\{v_{j,k,i}^{\prime }$} 9.                 Pk ←$\mathrm{Local} \mathrm{search} (R_k^{\prime }$) 10.     end for 11.     {Rk} ←$\min \{R_k, R_k^{\prime }$, Pk} 12.   end for 13.   output min C{Rk}

A local search algorithm is applied to IDJaya to expand the scope of solution exploration and improve the quality of solutions. In the local search algorithm, α is a randomly selected point in p_od. ε represents newly extended points that form a segment. Its steps are as follows: (1) randomly select a node in a path generated by IDJaya; (2) randomly access adjacent nodes from a node selected in the previous step; (3) stop access when a newly accessed node belongs to the initial path or the number of iterations reaches a set value; (4) connect several segments to form a new path; (5) repeat the above steps until the number of paths generated reaches the set value. It ends when the iteration is completed or a newly generated segment returns to the original path. Its time complexity is O(nβγ), and T_Local ≈ O(n) can be obtained. T_Local is the time complexity of a local search algorithm. n is the number of nodes. β and γ are two parameters in a local search algorithm. They mean that a local search algorithm is executed to generate at most β paths by exploring no more than γ nodes. Their settings need to prevent the algorithm from wasting too much computing time. As β and γ increase, more paths are generated, and accordingly, more high-quality solutions are likely to be obtained. However, as they increase, so does the running time. β and γ are not sensitive to the size of a network. Their values directly affect the selection range of alternative paths. Larger networks may require more alternative paths to find the optimal solution, but the size of a network does not affect β and γ values. After some experiments, we set β = 5 and γ = 10 as their proper values (Algorithm 2).

Algorithm 2. Local search algorithm

Input: A path generated by IDJaya (pod)     Output: A set of paths 1.  for β = 1 to 5 2.        $\mathrm{Randomly} \mathrm{select} \mathrm{a} \mathrm{node} {\alpha }_{\beta }$ in pod (except origin and destination) 3.        $\mathrm{Disconnect} {\alpha }_{\beta }$ from the other points in pod 4.        $\mathrm{Let} {\epsilon }_1$$={\alpha }_{\beta }$ and segment = ∅ 5.        for γ = 2 to 11 6.              $\mathrm{Random} \mathrm{access} \mathrm{from} {\epsilon }_{\gamma -1}$ $\mathrm{to} \mathrm{an} \mathrm{adjacent} \mathrm{node} {\epsilon }_{\gamma }$ (excluding connections severed in step 3) 7.              $\mathrm{if} {\epsilon }_{\gamma }$ ∈ pod 8.                P ← p 9.              end if 10.            segment ←segment + ${\epsilon }_{\gamma }$ 11.        end for 12.        $\mathrm{If} \epsilon \mathrm{is} \mathrm{close} \mathrm{to} \mathrm{origin} \mathrm{than} {\alpha }_1$ 13.              p ←segmentoε + segment + segmentαd 14.        else if 15.              p ←segmentoα + segment + segmentεd 16.        end if 17.              P ← p 18.          end for 19.  Output P

Theorem 1. 

The computational complexity of IDJaya is O($\widehat{I}$cK).

Proof of Theorem 1. 

First of all, we summarize the complexity of each step in IDJaya in

Table 1. IDJaya.

Input: Origin O, Destination D, Road network G, Population size K, Maximal iteration count $\widehat{I}$
Output: The shortest path
1. Calculate { COD }	O(cK)
2. Obtain the best value of f(x) (i.e., (COD)best) and the worst value of f(x) (i.e., (COD)worst)	O(K)
3. for i = 1 to $\widehat{I}$	(-)
4. for k = 1 to K	(-)
5.       for j = 1 to c	(-)
6.         $v_{j,k,i}^{\prime }={{\tilde{\phi }}_{j,k,i}r}_1{v}_{j,k,i}+{{\check{\phi }}_{j,best,i}r}_2{v}_{j,best,i}+{{\widehat{\phi }}_{j,worst,i}r}_3{v}_{j,worst,i}+{r_{4}v}_{j,random,i}$	O(4$\widehat{I}$cK)
7.       end for	(-)
8.       $R_k^{\prime }$ ← {$v_{j,k,i}^{\prime }$}	O($\widehat{I}$cK)
9.       Pk← Local search ($R_k^{\prime }$)	O(n$\widehat{I}$cK)
10. end for	(-)
11. {Rk} ← min{Rk, $R_k^{\prime }$, Pk}	O(2$\widehat{I}K$)
12. end for	(-)
13. output max C{Rk}	(-)

.

Based on Table 1, we formulate the computational complexity of IDJaya as follows:

$$\begin{array}{ll}T& =\mathrm{O}\left(cK\right)+\mathrm{O}\left(K\right)+\mathrm{O}\left(4\widehat{I}cK\right)+\mathrm{O}\left(\widehat{I}cK\right)+\mathrm{O}(2\widehat{I}K)+\mathrm{O}(K)+\mathrm{O}(n\widehat{I}cK)\\ & =n\mathrm{O}(\widehat{I}cK)+2\mathrm{O}(\widehat{I}K)+\mathrm{O}(cK)+2\mathrm{O}(K)\\ & \approx \mathrm{O}\left(\widehat{I}cK\right)\end{array}$$

where $\widehat{I}$ is the number of iterations and K is the population size. c is the number of nodes on a path. In the worst case, a path passes through all nodes in a network, i.e., c = m. On average, c << m. n is a constant. □

4. Experimental Results and Discussion

In this section, we illustrate IDJaya via a simple example and then perform two experiments to evaluate the proposed method.

4.1. A Simple Example

To illustrate how IDJaya works, Figure 4 shows a network example. It is an undirected graph consisting of 11 points and 16 edges. Vertical edges cost 3, horizontal edges cost 4, and hypotenuse edges cost 5. In a simple example, the origin is node “1,” and the destination is node “11”. Setting $\widehat{I}$ = 2 (i.e., the algorithm terminates after two iterations) and K = 3. There are three random initial paths, namely, “1-2-5-8-11”, “1-6-5-2-3-4-9-10-11” and “1-2-3-4-9-10-11”. We know that the optimal solution to this case is “1-6-7-11” and C_1-11 = 13. Since SPP is a minimization problem, the minimum value of C is regarded as the best solution, and the maximum value of C is the worst solution.

As shown in

Table 2. Initial paths and the corresponding C.

Alternate	Path	C1-11	Status
1	1-2-5-8-11	15	best
2	1-6-5-2-3-4-9-10-11	29	worst
3	1-2-3-4-9-10-11	21

, alternative paths 1 and 2 are the best and worst solutions, respectively. New paths are generated according to (7) and (8). For example, the first iteration of a new path corresponding to alternative path 1 is generated as follows:

(1)

$\begin{array}{ll}{v}_{\mathrm{1,1},1}^{\prime }& \leftarrow {\tilde{\phi }}_{\mathrm{1,1},1}{r}_1\left(v_2\right)+{\check{\phi }}_{1,best,1}{r}_2\left(v_2\right)+{\widehat{\phi }}_{1,worst,1}{r}_3\left(v_6\right)+r_4(v_2,v_6)\\ & \leftarrow r_1\left(v_2\right)+r_2\left(v_2\right)+r_3\left(v_6\right)+r_4(v_2, v_6)\\ & \leftarrow v_6\end{array}$

$p_1^{\prime }$:1-6

(2)

$\begin{array}{ll}{v}_{\mathrm{2,1},1}^{\prime }& \leftarrow r_3\left(v_5\right)+r_4(v_5,v_7)\\ & \leftarrow v_5\end{array}$

$p_1^{\prime }$:1-6-5

(3)

$\begin{array}{ll}{v}_{\mathrm{3,1},1}^{\prime }& \leftarrow r_1\left(v_8\right)+{r_2\left(v_8\right)+r}_3\left(v_2\right)+r_4(v_2, v_4,v_8)\\ & \leftarrow v_8\end{array}$

$p_1^{\prime }$:1-6-5-8

(4)

$\begin{array}{ll}{v}_{\mathrm{4,1},1}^{\prime }& \leftarrow r_1\left(v_{11}\right)+r_2\left(v_{11}\right)+r_4(v_7, v_9,v_{11})\\ & \leftarrow v_{11}\end{array}$

$p_1^{\prime }$:1-6-5-8-11

The above process gradually visits points in a network through the repeated calls of (7) to form a complete path. Similarly, new paths based on other initial paths are produced. Note that a newly produced node may jump out of the original path. For example, in Step 2), since node 6 has been visited, the original path and optimal solution do not include node 6, so let ${\tilde{\phi }}_{\mathrm{2,1},1}$ = ${\check{\phi }}_{2,best,1}$ = 0. Local search produces neighboring solutions for each new solution. For example, “1-6-5-8-11” is selected, in which node 5 is chosen at random. A segment “5-4-9-8” is generated by randomly accessing adjacent nodes starting at node 5. Here node 5 is closer to the origin than node 8. A new path is generated, i.e., “1-6-5-4-9-8-11”. These newly generated paths are compared, and the top 3 best solutions are put in

Table 3. New paths and the corresponding C during first iteration.

Alternate	Path	C1-11
1	1-6-5-8-11	15
2	1-6-7-11	13
3	1-2-5-4-9-10-11	21

. Compare the values of C_1-11 in Table 2 and Table 3, and place the top 3 best solutions in

Table 4. Final paths and the corresponding C at the end of first iteration.

Alternate	Path	C1-11	Status
1	1-2-5-8-11	15	worst
2	1-6-5-8-11	15
3	1-6-7-11	13	best

. This completes the first iteration.

It can be observed from Table 4 that path 3 is the best solution and the first candidate is the worst one. Entering the second iteration, new paths are generated using (7) and (8).

Table 5. New paths and the corresponding C during second iteration.

Alternate	Path	C1-11
1	1-2-3-4-5-8-11	21
2	1-2-5-8-11	15
3	1-6-7-11	13

shows the paths of new production and the corresponding C in the second iteration. Compare the values of C_1-11 in Table 4 and Table 5, and obtain the top 3 best solutions shown in

Table 6. Final paths and the corresponding C at the end of second iteration.

Alternate	Path	C1-11	Status
1	1-6-7-11	13	best
2	1-6-5-8-11	15	worst
3	1-6-7-11	13

. The second iteration is completed. IDJaya is terminated when $\widehat{I}$ = 2, and the optimal solution is output, i.e., “1-6-7-11”. It is determined that “1-6-7-11” is the optimal solution in this example by comparing the result with DA [16].

In the above example, it can be observed that the optimal solution is obtained in the first iteration. Although there is a small size network, it can reflect the simplicity of IDJaya. Subsequent computations may yield as good results as we have, but excellent solutions are retained by comparing original solutions with new ones. With the increase in population size and iterations, high-quality solutions can be obtained even if the size of a network continues to grow.

4.2. Case Study

4.2.1. Experiment Setting

In this section, seven road networks from Macao and seven dense graphs are used to verify the performance of IDJaya. Maps of Macao are given from ArcMap 10.2, and dense ones are generated at random. The sizes of actual instances arrange from 82 nodes and 135 edges to 1281 nodes and 1822 edges. Dense graphs arrange from 82 nodes and 676 edges to 1281 nodes and 151,397 edges. They are generated by ArcMap based on real road networks and with the same nodes as real road networks. All graphs have only non-negative costs. The algorithms devised in this paper are implemented in IDEA 2018.3 (the programming language is Java). We conduct the experiments on a laptop running Microsoft Windows 10 with an Intel/2.5 GHz Core (TM) i5-7300HQ CPU, 8 GB of RAM, and 1 TB of hard disk.

IDJaya is compared with typical Dijkstra [16] and very recent methods based on ant colony optimization (ACO) [31,66,67]. This work selects an improved ACO in [31] for comparison. Similarly, it also uses a swarm intelligence algorithm to solve the SPP, which is the latest and most relevant research to our work. The quality and running time of solutions are used to evaluate the performance of an algorithm. The solution quality is defined as follows:

$$\mathsf{\zeta }=1-\frac{c-\check{c}}{\check{c}}$$

(10)

where ζ is the quality of the solutions. The longer the path, the smaller the value. c and $\check{c}$ represent the cost of a path and the shortest path, respectively.

DA is parameter-free, IDJaya has two parameters, and ACO has five main parameters. IDJaya has the least number of super-parameters among all the meta-heuristic algorithms. Its two parameters are easy to determine. Increasing them tends to improve the quality of its solutions but takes more calculation time. Increasing the maximal iteration count may not necessarily improve the quality of solutions since IDJaya may fall into a local/global optimum. The increase in population size can effectively reduce the possibility of IDJaya falling into a local optimum. We set K = 50 and $\widehat{I}$ = 1000 in our experiment. The values of these parameters are determined based on some tests; acceptable near-optimal solutions can be obtained without spending a lot of running time. All instances are executed 50 times, and the averages are retained and compared.

4.2.2. Algorithm Performance

Experiments are carried out on real road networks and dense graphs, respectively. We randomly assign connections to generate dense graphs corresponding to real road networks, which have the same number of nodes. IDJaya, DJaya, Dijkstra algorithm (DA), and ACO are compared in terms of running time and accuracy. Note that DA always finds the shortest path as an exact algorithm. The results are reported in

Table 7. Running time of all compared algorithms in real networks.

Instances		Running Time (ms)
n	m	Dijkstra [16]			ACO [31]			DJaya			IDJaya
		Min	Avg	SD	Min	Avg	SD	Min	Avg	SD	Min	Avg	SD
82	135	52.7	60.4	13.4	75.3	85.0	6.5	22.5	33.7	7.4	23.6	35.9	6.3
203	288	64.3	71.8	15.9	93.9	102.1	7.3	31.2	42.7	9.8	35.9	50.4	6.9
443	621	248.7	279.1	10.7	116.7	127.4	9.8	67.0	87.5	13.6	78.4	96.1	7.9
633	900	494.9	554.8	20.4	129	156.9	25	97.1	126.4	19.9	101.5	134.3	14.1
860	1219	919.5	1000.8	27.5	225.8	257.6	24.4	142.3	180.1	28.6	173.7	205.8	18.4
1037	1470	1408.5	1444	16.5	496.4	553.9	29.8	180.7	219.3	30.1	198.1	253.2	24.7
1281	1822	2127.3	2215.4	37.6	947.8	1059.7	49.9	247.8	307.2	42.3	287.1	359.8	27.2

,

Table 8. Accuracy of all compared algorithms in real networks.

Instances		Accuracy
n	m	Dijkstra [16]	ACO [31]			DJaya			IDJaya
		Avg	Max	Avg	SD	Min	Avg	SD	Max	Avg	SD
82	135	100%	100%	100%	-	100%	100%	-	100%	100%	-
203	288	100%	100%	100%	-	100%	100%	-	100%	100%	-
443	621	100%	99.1%	97.1%	1.8%	100%	100%	-	100%	100%	-
633	900	100%	98.2%	95.6%	1.4%	100%	100%	-	100%	100%	-
860	1219	100%	94.8%	93.5%	1.8%	99.3%	98.6%	0.6%	100%	98.6%	0.6%
1037	1470	100%	93.0%	90.2%	1.6%	98.9%	98.1%	0.3%	99.3%	98.4%	0.9%
1281	1822	100%	89.9%	86.6%	1.9%	98.1%	97.6%	0.2%	98.4%	97.9%	0.4%

,

Table 9. Running time of all compared algorithms in dense graphs.

Instances		Running Time (ms)
n	m	Dijkstra [16]			ACO [31]			DJaya			IDJaya
		Min	Avg	SD	Min	Avg	SD	Min	Avg	SD	Min	Avg	SD
82	1281	62.9	86.6	11.5	77.5	91.7	10.6	24.9	33.5	6.63	20.9	37.1	15.0
203	4105	93.8	108.3	9.14	100.2	113.4	11.7	36.2	45.6	6.58	42.2	59.5	13.1
443	16,724	359.8	382.8	34.5	121.2	141.1	14.5	69.5	92.7	21.62	87.7	102.6	13.5
633	35,891	660.4	732.5	38.8	163.8	186.1	15.5	107.5	137.7	23.24	124.8	150.2	18.7
860	66,012	1268.3	1382.3	57.6	263.2	298.7	19.5	147.9	187.5	30.01	197.7	228.7	22.8
1037	106,324	1907.6	1988.3	56.1	594.8	621.9	27.0	194.3	246.6	39.58	264.5	287.4	14.2
1281	151,397	2606.1	2749.7	82.1	1121.3	1202.9	54.7	280.8	324.4	29.61	339.2	398.1	35.2

and

Table 10. Accuracy of all compared algorithms in dense graphs.

Instances		Accuracy
n	m	Dijkstra [16]	ACO [31]			DJaya			IDJaya
		Avg	Max	Avg	SD	Min	Avg	SD	Max	Avg	SD
82	1281	100%	100%	100%	-	100%	100%	-	100%	100%	-
203	4105	100%	100%	98.7%	1.0%	100%	100%	-	100%	100%	-
443	16,724	100%	98.4%	96.8%	1.5%	100%	100%	-	100%	100%	-
633	35,891	100%	97.5%	95.0%	1.1%	99.6%	99.5%	0.1%	100%	100%	-
860	66,012	100%	94.4%	92.4%	1.7%	99.0%	98.0%	0.6%	99.3%	98.5%	0.6%
1037	106,324	100%	91.2%	87.5%	2.3%	97.4%	96.8%	0.4%	98.0%	97.4%	0.3%
1281	151,397	100%	87.4%	82.9%	2.6%	97.0%	96.1%	0.4%	98.5%	97.2%	0.9%

. DJaya is an original discrete Jaya algorithm.

It can be seen from Table 7 that IDJaya and DJaya are always superior to DA in running time, and their advantage is increasing with the expansion of the network scale. The running times of IDJaya and DJaya are half of the DA when there are 82 nodes. When the number of nodes is 1281, their running time is only about one-seventh of the latter. Similarly, compared with ACO, our methods can give solutions of higher accuracy faster. DJaya’s running time is slightly less than IDJaya's since IDJaya runs a local search algorithm to increase accuracy. Figure 5 shows that their advantages in terms of calculation time become more and more significant as network size increases. As shown in Table 8, IDJaya and DJaya can always find the shortest paths in the first four instances. They both find the same near-optimal path in the fifth instance. The accuracy of IDJaya becomes more advantageous compared with DJaya and ACO as the network scale increases. Significantly, IDJaya can easily adjust parameters, and users can adjust them according to the SPP’s characteristics. Accuracy can be improved by increasing population size and iterations to meet higher accuracy requirements at the cost of longer running time.

We use high-density networks in Table 9 and Table 10. Similarly, IDJaya takes much less running time than DA and ACO and a bit more than DJaya. The increase in edges has a more significant impact on the calculation time of DA and ACO. The running time spent by IDJaya in dense graphs increases by only a tiny fraction compared to real road networks. Its solution accuracy has decreased but not significantly, falling within an acceptable range. The sixth instance is less accurate than the seventh at the maximum value of accuracy since IDJaya, as a meta-heuristic algorithm, is stuck at a local optimum at running and cannot find a better solution. This locally optimal solution is produced with some randomness. It is possible to obtain a better result in a more complex network.

In Figure 6, the running time of the three algorithms applied to different network types is compared. The increase in the number of edges has little effect on the running time of our algorithm, and DA needs to spend extra time dealing with massive edges. ACO is less affected than DA. As can be seen from the trend in Figure 6, as the number of nodes increases, the impact of the network density on running time is minimal for IDJaya. The time complexity of IDJaya also supports this result. Its time complexity is O($\widehat{I}$cK), and thus IDJaya has good performance on density graphs.

As shown in

Table 11. Comparison of Different Approaches.

Alternate	IDJaya	Dijkstra [16]	ACO [31]
Main idea	It always tries to move closer to the best solution and move away from the worst solution. Thus, the optimal solution is constantly approached.	Finding the shortest path by accessing and updating the distance of all points from an origin.	Mimicking ants’ foraging behavior. The shorter the path, the more pheromones. Eventually, the whole colony will converge on the optimal path.
Number of parameters	2	-	6
Number of related equations	2	2	5
Time complexity	O($\widehat{I}$cK)	O(n2)	O(n2)
Solution quality	Near-optimal solution (over 97%)	Optimal solution	Solution quality is worse than IDJaya

, the main ideas of IDJaya are introduced. Compared to existing heuristic algorithms, IDJaya is simpler and easier to implement since we only need to set two parameters for it. In the process of solving the SPP, just two equations need to be used to generate new solutions. IDJaya’s time complexity is O($\widehat{I}$cK), while the compared approach is O(n²). It can be seen that IDJaya’s time complexity is mainly affected by the maximal iteration count ($\widehat{I}$) and population size (K). When a network is large, the number of nodes far exceeds $\widehat{I}$ and K; thus IDJaya has an advantage in terms of running time.

5. Conclusions

The SPP is a combinatorial optimization problem widely seen in various engineering applications, especially transportation-related processes. To use the Jaya to solve the SPP, we have to discretize it and improve a generation strategy to make it suitable for the SPP. In this work, we successfully design an improved discrete Jaya algorithm to solve the SPP. We first adjust the discrete Jaya algorithm in [57], and a new solution generation strategy is given to make it suitable for the SPP. Then, we present a local search algorithm to increase the accuracy of this proposed method. The proposed IDJaya has the characteristics of short running time and excellent accuracy validated in many experiments with network sizes ranging from 82 to 1281 nodes. Computational results on seven real road networks and corresponding density graphs demonstrate that the proposed algorithm can yield high-quality solutions for the SPP with up to 1281 nodes and 151,397 edges in a short time. It should be noted that IDJaya performs very well in dense graphs. The results of its time complexity analysis show that increasing the number of edges has little influence on it.

Our future work plans to improve IDJaya further to obtain more accurate results and further explore its performance in large-scale networks [68]. IDJaya has the potential to be extended to solve other path problems, such as the constrained SPP and path planning problems in dynamic and 3-D networks. Its combination with recent deep learning methods [69,70,71,72,73] should be investigated to handle large-scale processes and systems [74,75,76,77,78,79,80,81,82,83,84]. Additionally, we are interested in considering the application of IDJaya to practical scenarios, i.e., industrial robots [39,40,41], automatic guided vehicle (AGV) [85,86], autonomous driving [87], resource scheduling [88,89] and multi-agent systems [77,90,91,92,93].