Implementation of robust routing is very critical in network communication. Connecting devices like routers maintain databases for the whole network topology in the routing table. Each router needs to keep these tables updated with the best possible routes so that an efficient communication can always take place in nondelay tolerant intelligent networks that include military and tactical systems, vehicular communication networks, underwater acoustic networks, and intelligent sensor networks. The fast construction of shortest-path tree (SPT) is important to devise an efficient routing in a nondelay tolerant networks. That is why a simple and efficient algorithm is the need of the time. A robust routing solution SPT with time complexity is proposed to supersede the existing landmark.

1. Introduction

Network routing is a backbone of intelligent communication networks specifically nondelay tolerant networks that include military and tactical systems, vehicular communication networks (VCNs), underwater acoustic networks (UANs), and intelligent sensor networks (ISNs) to send the communication data between vertices in a certain network. For the purpose, every router maintain routing tables. These tables manage routes of various network destinations. This network routing process is generally accomplished based on these routing tables and routes defined in them. This makes the formation, written in a memory of these routers, critically important for successful and efficient routing. There exist many graph theoretic solutions of this routing problem. In a network, the vertex of a graph represents a router, and edge/link which connect these vertices represents physical links between the routers.

The needs for broadband Internet applications have increased rapidly in today’s Internet. Which makes high speed routing inevitable and has become the key at open shortest-path first (OSPF). As a result of topological changes that take place due to due to an unavoidable circumstances at the OSPF, these algorithms update the routing table to handle the new topological changes. For example, if some link fails in a network, then there is no way but to recalculate these paths [1]. In such scenarios, these shortest paths are regenerated by running the algorithms again [2].

We can formally define shortest-path problem as follows:

Let , where and .

is an undirected nonnegative weighted connected graph (in this scenario, it will be representing the routing network). has a vertex “” designated as source and another vertex, “,”, designated as destination, such that . We need to find simple path(s) from to with minimum incurred cost.

[3] presented a hybrid model with local and global modes. A fixed graph model is used to present the local mode connections. In the paper, they denoted graph by a unit-disk graph UDG(V): for any , {u,v} ∈ UDG(V) if and only if distance between and is less than 1. For the local mode, in each round, node can send a message of bits to node . For the global mode, they used a variant of the node-capacitated clique (NCC) model presented in [4] that describes salient features of overlay networks. In [5], the authors explain the SPSN approach including route object modeling, capacity-oriented search, and possible route organization procedures. Prototype assessments presented significant support that SPSN is better than the legacy CGR in more than an order of magnitude in contact plans comprising thousands of contacts.

The shortest-path tree (SPT) problem is one of the most well-known problems in graph theory [6]. Since 1959, most of the advances in SPT for general graphs, directed and undirected, are based on Dijkstra’s algorithm. There exist lots of applications of SPT problems like computer systems, transportation networks, and vehicle routing [7]. Time complexity of the basic algorithm of Dijkstra [8] is calculated as (where is number of vertices and is number of edges) if linear search is applied to find the minimum [9]. [10, 11] introduced a new data structure, heap, to find the minimum. This new data structure improved the time complexity to . Fibonacci heap improved this bound further [12]. Authors of [12] used comparison model for the optimal implementation of Dijkstra’s algorithm as Dijkstra’s algorithm traverses vertices in ascending order.

In [13], with the use of optimal structure of the data, heap data structure provides the complexity of with implementation of Dijkstra and Fibonacci heap gives the complexity of with the implementation of Dijkstra. For the stochastic decision-making problem in [14], the stochastic dynamic programming solution is required. The generalized elementary shortest-path problem in [15] shows that two-phase heuristic graphs by including negative cycles can improve the average gap of 0.3% if compared with the best known solutions if number of vertices are set to 100. The solution in [16] suggests that these algorithms can be implemented in all kind of networks with complexity of Dijkstra , Bellman , and Floyd . The paper [17] suggests a solution with complexity for a fast delivery problem. The complexity of Bellman is , and the complexity of Dijkstra is if the network is fully connected or near to the fully connected [18].

Invent of fusion trees and its application in Dijkstra’s algorithm make randomized bound of time complexity, . Later, the invention of atomic heaps improved this time bound to bound and [12]. Afterwards, in [6, 19, 20], priority queues improved to and . These worst-case time bounds are randomized supposing linear space are prerequisite. The researcher of [21] further improved it to which was improved by the authors of [16], next year, using randomized bound to .

[2] presented priority queue, which improved single source shortest-path cost to where is the cost of the most heavy edge. This bound was further improved by [22] to expected time, and [23] presented a further improvement to . The authors of [24] claimed that the algorithm they have presented will outclass Dijkstra algorithm.

In [25], the authors presented an exact adjacency-based primal algorithm to resolve the SPT problem with high resources. Their algorithm explored solution space iteratively using path adjacency-based partition. They claimed optimal convergence with good path in lesser cost. Authors of [26] introduced a multiobjective (time and cost) shortest-path tree problem for connected directed graphs. Every edge was having two cost values. They proved that uncertainty MSPP reduced the total travel time and cost.

[27] used a dual evolutionary algorithm while analyzing the problem of clustered shortest-path tree. Their first algorithm (N-LSE) targeted the minimization of search space with fewer vertices. The second algorithm named M-LSE using N-LSE creates smaller and multiple intercluster edges. [28] solved the dynamic SP problem to solve time-dependent TSP. In logistic planning where traffic data is rich enough, time-dependent path optimization techniques give considerable benefits. Dynamic shortest-path solution contains no length cycles and resolves the complexity problem when compared to acyclic graph-based methods.

In [29], the author reviewed many popular algorithms for solving the SPT problem in weighted graphs. He proposed two variants of Dijkstra’s algorithm. He presented asymptotic comparison different variants of Dijkstra’s algorithm on expanded graphs. He presented time algorithm where and . They used color-in and color-out scheme.

2. Concept

This work presents a novel algorithm of finding shortest-path routes in intelligent networks. This algorithm is based on bidirectional search where first search is starting from source vertex, and its target is destination vertex, while second search starts from the destination vertex, and its target is source vertex. It is analogous to two robots looking for each other from two distinct points. First robot, , starts its search from its current position, and let us call it , and second robot, , starts its search from its current position, and let us call it . explores all possible paths, in BFS fashion, looking for or . In the same way, will be exploring all possible paths, simultaneously, looking for either or . Following are the three possible situations that can rise, in this bidirectional search. (i) will find (ii) will find (iii) and meets at position,

Situation i is the simplest one. Let be the path that has explored and has vertices , where is .

In situation ii, has found . It means that path is found but in reverse order. Let has explored the vertices in sequence , where is .

The reverse of this will generate the required path. See the following equation:

In situation iii, it is little complex than the previous two. Two paths— and , need to be concatenated. Let be the path that has explored and has vertices . is the path that has explored and has vertices , where and are the same vertices as and and are and , respectively. The required path will be having vertices in the sequence , as given in equation (3).

3. Proposed Algorithm

The proposed algorithm targets only those graphs in which on two paths, from source, and , to fulfil the following property: where and and and and are paths from to such that and

The search is executed, parallel, from both ends—source, , and destination, . Vertices are explored level by level. Best paths are calculated by concatenating the new edge with previously explored best path, and cost is calculated by adding the cost of all edges in that path from source.

Each vertex during the execution goes through three states, being represented by three colors—green, yellow, and red. The definitions of these colors can be seen in Table 1

Initially, all vertices, i.e., , are initialized with Starting from and , independently and simultaneously, the current vertex, let us call it , will explore its neighbors. Every neighbor, i.e., , is updated with shortest-path cost, and let us call it SPCost, parent, i.e., and color, i.e., .

Update will be effective if new reflects improvement over previously stored one.

Initially all vertices have green status. As soon as a vertex is explored during the search, its status is updated to yellow. As soon as any vertex completes its exploration (i.e., all its neighbors are explored, and their status is changed to yellow), its status is updated to red.

Exploration takes place, strictly, level by level. No next level vertex is explored until all the previous level yellow vertices’ status is change to red. As soon as one level is completed, the control is switched to the other part of the algorithm to proceed and it also performs the identical steps.

During the search of any side if some red (light or dark) vertex is explored by the counterpart search, then two shortest paths are calculated and stored. If some shortest path has already been stored, then the path will less cost will be kept.

The algorithm terminates when the status of all vertices is updated to red (light or dark). In worst case, depending upon the type of the graph, it finishes in time. If graph is totally disconnected, even then loop in line number 4 of ShortestPath will execute for times. If graph is connected and is having , then combined effect of line number 4 of ShortestPath and line number 2 of SPfromSource or SPfromDestination would be “all adjacents of all vertices” will cost which will make it . Detailed algorithm can be seen in Algorithm 1.

ShortestPath(s, t, G)
1. Queue1.enQueue(s)
1. Queue2.enQueue(t)
2. InitializeDoubleSource(SPCost, Pi, Clr, s, t, G)
3.  Flag ← 0
4. While (Queue1 <> Null OR Queue2 <> Null) AND Flag = 0
5.  Do SPfromSource(SPCost, Pi, Clr, G)
6.   SPfromDestination(SPCost, Pi, Clr, G)
1. while u ← Queue1.deQueue() <> Green
2. for each v belongs to Adj[u]
3.  do if Clrv = Green OR LightYellow OR LightRed
4.    then Clrv ← LightYellow
5.      SPCostv ← min(SPCostu +W(u,v), SPCostv)
6.      If SPCost is updated
7.       Then Piv ← u
8.      If Clrv = Green OR LightRed
9.       Then Queue.enQueue(v)
10.    If Clrv = DarkRed
11.     Then Concatinate two paths and store
12.        CPCost ← min(CPCostu + CPCostv + w(u,v), CPCost)
13.    If Clrv = DarkYellow
14.     then skip
15. Clru ← LightRed
1. while u ← Queue2.deQueue() <> Green
2. for each v belongs to Adj[u]
3. do if Clrv = Green OR DarkYellow OR DarkRed
4.  then Clrv ← DarkYellow
5.  SPCostv ← min(SPCostu +W(u,v), SPCostv)
6.  If SPCostv is updated
7.   Then Piv ← u
8.  If Clrv = Green OR DarkRed
9.   Then Queue.enQueue(v)
10. If Clrv = LightRed
11.  Then Concatinate two paths and store
12.    SPCostv ← min(SPCostu + SPCostv + w(u,v), SPCostv)
13. If Clrv = LightYellow
14.    then skip
15. Clru ← DarkRed

4. Working Example of the Algorithm

All vertices are initialized using equation (7) (see Figure 1). Both sources— and , are colored yellow and their SPCosts are marked 0 (see Figure 1(a)). All vertices are enqueued. Main subroutine (named ShortestPath) of the algorithm calls the two replicated subroutines (named SPfromSource and SPfromDestination) one by one until queue has any vertex.

The subroutine SPfromSource dequeues a vertex, it would be source, and here in this example, it is . Algorithm then explores all its neighbors—, , and , one by one.

Equations (8)–(10) are used to update the values of SPCost, , and Clr. In the same way, SPfromDestination dequeues a vertex, it would be destination, and here in this example, it is . Algorithm then explores all its neighbors— and , one by one. Equations (8)–(10) are used to update the values of SPCost, , and Clr. and are colored red after all explorations. New updated status can be seen in Figure 1(b).

In the same way, SPfromDestination dequeues a vertex, and it would be path, equations (9) and (10). Figures 1(c), 1(d), and 2(a) explain these iterations one by one. Figure 2(b) shows that a red vertex is explored from the other side. It generates case 3 (i.e., “ and meet at position, ”). Path from both sides along with currently updating edge is concatenated to form a path using equation (7). This path is stored.

This process of dequeuing, exploring, and generating new path continues until both queues have no vertices. New paths are generated and compared with the stored one and is discarded if old one is better Figure 2(c). But if new path is better than the old one, it is replaced with the old one. The process ends with the shortest possible path.

5. Discussion

The main advantage of this algorithm is due to the nature of the networks in which it is not possible that indirect distance can be smaller than direct distance between two vertices. Since Dijkstra invented his SPT algorithm, the research community has worked mostly in the similar direction: choose a node to propagate in nondecreasing order and manage and update neighboring vertices through it. To select vertices in a nondescending order, the half-explored vertices must be sorted, or on each selection, the minimum distance must be calculated from the remaining vertices, which again is equivalent to sort [29].

The main bottleneck of these algorithms is the intermediary sorting algorithm. Most researchers have worked to surmount this bottleneck. New data structures like tree, heap, and priority queue were designed to improve the time bounds. One of these is Fibonacci heap [30] that resulted in the best known asymptotic bound of Dijkstra’s algorithm [31]. However, this bound is also criticized by researchers due to the heavy processes of Fibonacci heap [3237]. This algorithm is beating this bound of Dijkstra’s algorithm using Fibonacci heap, where sorting is not being attempted in any form. On one side, it is thrashing this time bound with simple data structure and no sorting algorithm; on the other side, it has parallelization in its nature that is beyond the scope of this paper.

At the same time, this algorithm is also better than the one presented in [29] with worst-case time bound of time algorithm where and . The algorithm proposed in this research has worst-case time bound of, which is linear in time and hence is better than the one presented in [29] for routing in intelligent networks [3842].

6. Conclusion

The proposed SPT algorithm executes with time which is relatively better than the state of art work. It is simple to understand and easy to implement and does not require high computational resources. It has additional benefit that after some specific stage, it can always hold a path from source to destination if compromise on quality of path is possible to address the latency issues in nondelay tolerant networks that include military and tactical systems, vehicular communication networks, underwater acoustic networks, and intelligent sensor networks.

Data Availability

No data were used to support this study.

Conflicts of Interest

The authors declare that they have no conflicts of interest.