1. Introduction

2. Related work

3. Methods and materials

3.2. The pruned Dijkstra

The pruned Dijkstra algorithm is an optimized version of Dijkstra’s algorithm in which unnecessary paths are removed in the search, keeping a list of pending nodes and choosing to expand the one with the minimum distance in the list. If we find a path longer than the currently known shortest path to any node during expansion, then that path is discarded and not considered again. In this way, the pruned Dijkstra algorithm reduces the number of paths to be considered. It is a generalization of the PLL (Pruned Landmark Labeling) method for undirected weighted graphs [70]. The PLL method is based on the idea of 2-hop coverage [72], which is an exact method. It is defined as follows: let $G=(V,E)$ be an undirected and weighted graph; for each node $v\in V$, the cover $L\left(v\right)$ is a set of pairs $(u,{\delta }_{uv})$, where u is a node and ${\delta }_{uv}$ is the distance from u to v in the graph G. All covers are denoted as indexed $L{\left(v\right)}_{v\in V}$. To calculate the distance between two vertices, s and t, we use the search function (Q), as shown in Eqn. 1. L is a two-hop cover of G if $Q(s,t,L)={\delta }_{st}$ for any $s,t\in V$.

$$Q(s,t,L)=\left\{\begin{array}{cc}\infty \hfill & L\left(s\right)\cap L\left(t\right)=\varnothing \hfill \\ min\left\{{\delta }_{vs}+{\delta }_{vt}|(v,{\delta }_{vs})\in L\left(s\right),(v,{\delta }_{vt}\in L\left(t\right)\right\}\hfill & L\left(s\right)\cap L\left(t\right)\ne \varnothing \hfill \end{array}\right.$$

(1)

In the case of weighted directed graphs, it is necessary to calculate two indexes; the first $L^{in}$ contains the coverage of all the nodes, considering the incoming edges. The second $L^{out}$ considers the outgoing edges. The way to consult the distances has a minor modification, but the idea remains the same. Such change can be observed in Eqn. 2.

$$Q(s,t,L)=\left\{\begin{array}{cc}\infty \hfill & L{\left(s\right)}^{in}\cap L{\left(t\right)}^{out}=\varnothing \hfill \\ min\left\{{\delta }_{vs}+{\delta }_{vt}|(v,{\delta }_{vs})\in L{\left(s\right)}^{in},(v,{\delta }_{vt}\in L{\left(t\right)}^{out}\right\}\hfill & L{\left(s\right)}^{in}\cap L{\left(t\right)}^{out}\ne \varnothing \hfill \end{array}\right.$$

(2)

A naive way to build these indexes is through two executions of Dijkstra’s algorithm. Although this method needs to be more obvious and effective, we will explain the details to discuss the next method. Let $V=\{v_1,v_1,...,v_n\}$, start with an empty index $L_0^{in}$, where $\forall u\in V,L_0^{in}\left(u\right)=\varnothing$. Suppose Dijkstra is used on each vertex in the order $v_1,v_2,...,v_n$. After the k-th Dijskstra on a vertex $v_k$, the distances of $v_k$ are added to the coverages of the vertices reached, whereby $L_k^{in}\left(u\right)=L_{k-1}^{in}\left(u\right)\cup \left\{(v_k,d_G(v_k,u))\right\}$ for each $u\in V$ with $d_G(v_k,u)\ne \infty$, where $d_G(u,v)$ is the distance from node u to node v within the graph G. It is important to mention that the coverages of the vertices reached are not changed, which implies $L_k^{in}\left(u\right)=L_{k-1}^{in}\left(u\right)$ for each $u\in V$ with $d_G(v_k,u)=\infty$. By performing this procedure starting with $L_0^{out}$, the same result can be obtained but considering the output edges.

Thus, $L_n^{in}$ and $L_n^{out}$ are the final indices contained in $L_n$. Obviously, $Q(s,t,L)=d_G(s,t)$ for any pair of vertices, therefore $L_n^{in}$ and $L_n^{out}$ are the 2-hop covers of G. This is because, if s and t are reachable, then $(s,0)\in L_n^{in}\left(s\right)$ and $(s,d_G(s,t))\in L_n^{out}\left(t\right)$.

As mentioned at the beginning of the description, this way of creating indexes could be more efficient. For this reason, pruning is added to the naive method. This technique reduces the search space considerably. Like the naive method, a pruned search is conducted with Dijkstra’s algorithm starting from the vertices in the following order: $v_1,v_2,...,v_n$. Start with a pair of indices $L_0^{in}$, $L_0^{out}$ and create indices $L_k^{in}$, $L_k^{out}$ from $L_{k-1}^{in}$ and $L_{k-1}^{out}$, respectively, using the information obtained by the k-th execution of pruned Dijkstra for vertex $v_k$.

The pruning process is as follows: suppose we have the indices $L_{k-1}^{out}$ and $L_{k-1}^{in}$ and we execute the pruned Dijkstra from $v_k$ to create a new index $L_k^{out}$. Assuming that we are visiting a vertex u with distance $\delta$. If $Q(s,t,L_{k-1})\le \delta$, then we prune u, that is, we do not add $(u_k,\delta )$ to $L_k^{out}\left(u\right)$ and we do not add any neighbors of u to the priority queue. If the condition is not met, then $(u_k,\delta )$ is added to the cover of u, and Dijkstra is executed as normal. As with the naive method, we set $L_k^{in}\left(u\right)=L_{k-1}^{in}\left(u\right)$ and $L_k^{out}\left(u\right)=L_{k-1}^{out}\left(u\right)$ for all vertices that were not reached in the k-th execution of the pruned Dijkstra. In the end, $L_k^{out}$ and $L_k^{in}$ are the final indices contained in $L_k^{{}^{\prime }}$.

Figure 3 shows an example of the algorithm acting on the graph represented in the figure, taking the order of execution as $1,8,2,3,4,5,6,7,9,10,11,12$. The first pruned Dijkstra from vertex one visits all other vertices, forward and reverse (see Figure 4a and Figure 4b). During the next iteration from vertex 8 (Figure 5e), when node one is visited, given that $Q(8,1,L_1^{{}^{\prime }})=1=\delta (8,1)=$1, vertex one is pruned and none of its neighbors are visited anymore; the same occurs in the opposite direction (see Figure 5f). With these two executions, it is possible to cover all the shortest paths, and once the process is executed on the remaining vertices, they will only refer to themselves. The pruned Dijkstra algorithm is described in Algorithm 2, and the whole algorithm for constructing indices is presented in Algorithm 1.

Algorithm 1:APSP_PDijkstra

We executed the pruned Dijkstra in order $v_1,v_2,...,v_n$; and arbitrarily chose the order of the vertices; however, it is relevant for a good algorithm performance. Ideally, start from central vertices so that many shortest paths pass through them. There are many strategies to order the vertices; some of the most used ones apply to order by centralities. In this work, we choose the order of the vertices by the degree of centrality. The graphs generated by semantic networks behave like networks without scale, where high-degree vertices provide high connectivity to the network. In this way, the shortest path between two vertices will likely pass through those nodes.

Algorithm 2:The Pruned Dijkstra

Algorithm 3: Check distance from source to target nodes according a 2-hop cover

3.2.1. The pruned Dijkstra analysis

To prove the correctness of the method, it suffices to show that the algorithm computes a two-hop coverage, that is, $Q(s,t,L_k^{{}^{\prime }})=d_G(s,t)$ for any $s,t\in V$. Let $L_k$ be the index built without the pruning process, so it is a two-hop coverage; $L_k^{{}^{\prime }}$ is the index built by applying the pruning process. Since there exists a node $v_j$ such that $(v_j,d_G(v_j,s))\in L_k{\left(s\right)}^{in}$, $(v_j,d_G(v_j,t))\in L_k{\left(t\right)}^{out}$ and ${\delta }_{v_j,s}+{\delta }_{v_j,t}=d_G(s,t)$, the goal is to show that $v_j$ also exists in $L_k^{{}^{\prime }}{\left(s\right)}^{in}$ and $L_k^{{}^{\prime }}{\left(t\right)}^{out}$.

Theorem 1.

For $k=1,...,n$, and $s,t\in V$, $Q(s,t,L_k^{{}^{\prime }})=Q(s,t,L_k)$

Proof. 

Let $s,t\in V$, assume there is a path between them, j the smallest number such that $(v_j,d_G(v_j,s))\in L_k{\left(s\right)}^{in}$ , $(v_j,d_G(v_j,t))\in L_k{\left(t\right)}^{out}$ and ${\delta }_{v_j,s}+{\delta }_{v_j,t}=d_G(s,t)$. We must show that $(v_j,d_G(v_j,s))$ and $(v_j,d_G(v_j,t))$ also lie in $L_k^{{}^{\prime }}{\left(s\right)}^{in}$ and $L_k^{{}^{\prime }}{\left(t\right)}^{out}$ respectively; that is to say that $Q(s,t,L_k^{{}^{\prime }})=Q(s,t,L_k)$. To prove that $v_j\in L_k^{{}^{\prime }}{\left(t\right)}^{out}$, first, for any $i<j$, suppose $v_i\in P_G(s,v_j)$, where $P_G(a,b)$ is a path between a and b. If we assume that $v_i\in P_G(v_j,t)$, by inequality:

$$\begin{array}{cc}\hfill Q(s,t,L_k)& =d_G(s,v_j)+d_G(v_j,t)\hfill \\ \hfill & =d_G(s,v_j)+d_G(v_j,v_i)+d_G(v_i,t)\hfill \\ \hfill & \ge d_G(s,v_i)+d_G(v_i,t)\hfill \end{array}$$

Since $(v_i,d_G(v_i,s))\in L_k{\left(s\right)}^{in}$ and $(v_i,d_G(v_i,t))\in L_k{\left(t\right)}^{out}$, it contradicts the fact that j is the smallest number. Therefore, $v_i\notin P_G(v_j,t)$ for no $i<j$.

Now, we prove that $(v_j,d_G(v_j,t))\in L_k^{{}^{\prime }}{\left(t\right)}^{out}$. Suppose we execute the j-th Dijkstra pruned from node $v_j$ to construct index $L_j^{{}^{\prime }out}$. Let $t\in P_G(v_j,t)$. Since there is no $v_i\in P_G(v_j,t)$ for $i<j$, it means that there is no vertex in the i-th pruned Dijkstra iteration that covers the shortest path of $v_j$ to t, therefore $Q(v_j,t,L_{j-1}^{{}^{\prime }})>d_G(v_j,t)$. Consequently, vertex t is visited without pruning and $(v_j,d_G(v_j,t))\in L_j{\left(t\right)}^{out}\subseteq L_k{\left(t\right)}^{out}$ is added.

Finally, suppose we execute the j-th Dijkstra pruned from $v_j$, but this time to build $L_j^{{}^{\prime }in}$. If s and t are reachable in G, it means that there is a path between $v_j$ and s taking into account the input edges, or what is the same, there is $P_G(s,v_j)$. Since we already proved that $v_i\notin P_G(v_j,t)$ for $i<j$, it means that $v_j$ is a neighbor of s or $v_j=s$, and since $v_j$ is the initial vertex of the path $P_G(v_j,t)$, then $v_j$ is the least distance neighbor sharing s. In any of the cases $Q(s,v_j,L_{j-1}^{{}^{\prime }})>d_G(s,v_j)$, therefore the node s is visited without pruning (remember that it is considering the input edges). Consequently $(v_j,d_G(v_j,s))\in L_j{\left(s\right)}^{in}\subseteq L_k{\left(s\right)}^{in}$ is added.    □

As mentioned, the order in which the nodes are processed influences the algorithm’s performance. Is there an order of execution such that the construction time is the minimum possible? The answer is yes; however, finding such an order is challenging. So, there are two approaches: the first is to find the minor nodes that cover all the shortest paths, which is a much bigger problem since this is an instance of the minimum vertex coverage problem that is NP-hard. The second approach is a parameterized perspective; specifically, the explored parameter is the width of the tree. It also relies on the process of centroid decomposition of the tree [73]. This approach deduces the following lemma; the formal proof is made in [70].

Lemma 1.

Let w be the width of the graph of G. There is a vertex order with which the pruned Dijkstra method executes in time $\mathcal{O}\left(wmlog\left(n\right)+w^{2}n{log}_2\left(n\right)\right)$ for preprocessing, stores an index with space $BigOwnlog\left(n\right)$ and answers each query in $\mathcal{O}\left(wlog\left(n\right)\right)$ time.

Considering that this research study does not look for minimum two-hop coverage, using the upper bound of $\mathcal{O}\left(wmlog\left(n\right)+w^{2}n{log}_2\left(n\right)\right)$ for the algorithm can be considered an inconsistency. Since there is no guarantee that the chosen order (degree centrality) is the same as the order necessary to achieve such computational complexity, however, what we concluded for our implementation is that it cannot be faster than the one theoretically obtained using the order with which $\mathcal{O}\left(wmlog\left(n\right)+w^{2}nisachieved.lo{g}_2\left(n\right)\right)$. That is, our implementation has a lower bound $\Omega (wmlog\left(n\right)+w^{2}n{log}_2\left(n\right))$. Also, in terms of Dijkstra’s algorithm, we can hypothesize that the construction of the coverage using the pruned process, regardless of the order of execution, is much smaller than for the construction of the naive coverage in highly connected graphs, that is to say, that $\mathcal{O}\left(mn+n^{2}log\left(n\right)\right)$.

3.3. The sketches

Sketch-based algorithms are methods comprising two general processes: offline and online. In the offline process, the sketches (that are crucial nodes, initially random) are computed from which the shortest path to all the other nodes is calculated. In the online process, we compute the closest distance between a pair of nodes $u,v\in V$ from the closest common sketch between them.

The offline process consists of sampling $log\left(n\right)$ sets of seed nodes, each containing a subset $S\subseteq V$ of size $2^i,i=1,2,3,...,log\left(n\right)$. From each set, the closest seed $s\in S$ of each node is stored together with its distance; that is, for each node u, a sketch of the form SKETCH$\left(u\right)=\left\{(s,{\delta }_{s,u})\right\}$ is created. Therefore, the final size of the sketch for each node is $log\left(n\right)$. This construction can be made with Dijkstra’s algorithm. The node $s\in S$ closest to u is called the seed of u. This procedure is executed k times with different sample sizes. At the end of the k iterations, we obtain $klog\left(n\right)$ seeds for each node.

As with the previous algorithm, we must compute two sketches for each node. The first SKETCH${}^{out}\left(u\right)$ and SKETCH${}^{in}\left(u\right)$ representing the distance from node $u\in V$ to the nearest seed and vice versa. We do this by running the search algorithm twice; one considering the input edges, the other with the output edges.

We can randomly choose S, using some criteria to bias our choice. For example, we can discard those nodes whose degree is less than two. We can also take advantage of the graph’s structure, and its specific properties5. In the Algorithm 4, the proposed pseudocode is shown to generate the sketches of each node.

Algorithm 4:Sketches_DIS-C: offline sampling

For each sample, we obtain the closest seed node and its distance for each node. This process is done with the classical Dijkstra multi-source algorithm. In this way, the seed nodes for each $u\in V$ are computed (see Algorithm 5).

Algorithm 5:Sketches_DIS-C: k sketches offline

In each iteration, we generated a sketch from an offline sample; therefore, at the end of the algorithm, there will be $klog\left(n\right)$ seeds for each node.

The second process of the method is the online one. The calculation of the approximate minimum distance between nodes u and v is done by looking at the distance from u and v to any node w that appears in both ${\mathcal{S}}_u^{in}$ as in ${\mathcal{S}}_v^{out}$. So, we compute the path length from u to v by adding the distance from u to w plus the distance from w to v. The minimum distance is taken if there are two or more common nodes w. Algorithm 6 shows the proposal to perform said calculation.

Algorithm 6:Sketches_DIS-C: k sketches online

Finally, to solve the APSP problem, it is necessary to create another algorithm that it executes for each pair of nodes (Algorithm 7).

Algorithm 7:Sketches_DIS-C: k sketches online APSP

Figure 5 shows an example of the described procedure. The graph of Figure 3 is taken as a reference. Since there are 12 nodes, the number of seed sets is 3 (${log}_2\left(12\right)=3$), and the size of the sets are 1, 2, and 4, respectively. The nodes in each set are 1; for the first, $3.1$; for the second, and $8,1,2,7$, for the last.

In the first iteration (Figure 5a), all the nodes have node 1 in their coverage; this also happens for the input edges (see Figure 5b). In the second iteration (Figure 5c and Figure 5d), the coverages do not change since node three does not cover any path shorter than those already covered by node 1, finally, in the last iteration (Figure 5e and Figure 5f), we have node 8 in the seed set, this covers the shortest path of its neighbors, except those that are also in the set; therefore, nodes 5, 12 and 9 will have 8 in their coverage. On the other hand, nodes 2 and 7 are contained in their respective coverage.

3.3.1. Sketches analysis

In the sketches-based method, there is no accuracy test for general graphs. It means that the method does not guarantee exact node labeling to answer the exact distance between all pairs of vertices. As far as computational complexity is concerned, it is easy to determine.

Theorem 2.

For a set of nodes $S\subseteq V$ such that the size of said set is $2^w$ for $0\le w\le n$, the computational complexity of the algorithm is $\mathcal{O}\left(w(m+nlog(n\left)\right)\right)$.

Proof. 

We know that the sketch-based method selects a number w founded on the number of nodes in the graph, that is, $w=f\left(V\right)\le \left|V\right|$. Then, given w, $Q_i$ subsets of nodes are created for $i=0,1,2,...,logn$ such that the size of each one is $|Q_i|=2^i|i=0,1,...,w$. It can be seen that $S={\bigcup }_{i=0}^w{Q}_i$. For each of the $Q_i$ subsets, the multi-source Dijkstra algorithm is executed, with the aim of finding, for all the nodes of G, the closest node of the $Q_i$ set. Dijkstra’s algorithm from multiple sources has a complexity of $\mathcal{O}\left(m+nlog\left(n\right)\right)$; for each subset of nodes, it is necessary to apply (independent of size) a single execution of Dijkstra’s algorithm. Therefore, since there are w subsets of nodes, w Dijkstra processes from multiple sources must be executed; that is to say, in total, we reach a complexity of $\mathcal{O}\left(w(m+nlog(n\left)\right)\right)$. □

In the implementation carried out in this work, we determined w by a logarithmic function $w={log}_2\left(n\right)$, where $n=\left|V\right|$. In this way, we ensured that $\left|S\right|<\left|V\right|$. Therefore, for the implementation made, the method has a complexity of $\mathcal{O}\left({log}_2\left(n\right)(m+n{log}_2\left(n\right))\right)$.

4. Experiments and execution scenarios

5. Experimental results

6. Conclusions

References

1. Dreyfus, S.E. An appraisal of some shortest-path algorithms. Operations research 1969, 17, 395–412.
2. Gallo, G.; Pallottino, S. Shortest path algorithms. Annals of operations research 1988, 13, 1–79.
3. Magzhan, K.; Jani, H.M. A review and evaluations of shortest path algorithms. Int. J. Sci. Technol. Res 2013, 2, 99–104.
4. Madkour, A.; Aref, W.G.; Rehman, F.U.; Rahman, M.A.; Basalamah, S. A survey of shortest-path algorithms. arXiv preprint arXiv:1705.02044 2017.
5. Fuhao, Z.; Jiping, L. A new shortest path algorithm for massive spatial data based on Dijkstra algorithm [J]. Journal of LiaoNing Technology University:(Natural Science and edition) 2009, 28, 554–557.
6. Chakaravarthy, V.T.; Checconi, F.; Murali, P.; Petrini, F.; Sabharwal, Y. Scalable single source shortest path algorithms for massively parallel systems. IEEE Transactions on Parallel and Distributed Systems 2016, 28, 2031–2045.
7. Yang, Y.; Li, Z.; Wang, X.; Hu, Q.; others. Finding the shortest path with vertex constraint over large graphs. Complexity 2019, 2019.
8. Liu, J.; Pan, Y.; Hu, Q.; Li, A. Navigating a Shortest Path with High Probability in Massive Complex Networks. Analysis of Experimental Algorithms: Special Event, SEA² 2019, Kalamata, Greece, June 24-29, 2019, Revised Selected Papers. Springer, 2019, pp. 82–97.
9. Quintero, R.; Torres-Ruiz, M.; Menchaca-Mendez, R.; Moreno-Armendariz, M.A.; Guzman, G.; Moreno-Ibarra, M. DIS-C: conceptual distance in ontologies, a graph-based approach. Knowledge and information systems 2019, 59, 33–65.
10. Mejia Sanchez-Bermejo, A. Similitud semantica entre conceptos de Wikipedia. B.S. thesis, 2013.
11. Quintero, R.; Torres-Ruiz, M.; Saldaña-Pérez, M.; Guzmán Sánchez-Mejorada, C.; Mata-Rivera, F. A Conceptual Graph-Based Method to Compute Information Content. Mathematics 2023, 11, 3972.
12. Meersman, R.A. Semantic ontology tools in IS design. In Lecture Notes in Computer Science; Springer Berlin Heidelberg, 1999; pp. 30–45. [CrossRef]
13. Sanchez, D.; Batet, M.; Isern, D.; Valls, A. Ontology-based semantic similarity: A new feature-based approach. Expert systems with applications 2012, 39, 7718–7728.
14. Rada, R.; Mili, H.; Bicknell, E.; Blettner, M. Development and application of a metric on semantic nets. IEEE transactions on systems, man, and cybernetics 1989, 19, 17–30.
15. Wu, Z.; Palmer, M. Verb semantics and lexical selection. arXiv preprint cmp-lg/9406033 1994.
16. Hirst, G.; Stonge, D. Lexical Chains as Representations of Context for the Detection and Correction of Malapropisms. WordNet: An Electronic Lexical Database 1995, 305.
17. Miller, G.A. WordNet: a lexical database for English. Communications of the ACM 1995, 38, 39–41.
18. Li, Y.; Bandar, Z.A.; Mclean, D. An approach for measuring semantic similarity between words using multiple information sources. IEEE Transactions on Knowledge and Data Engineering 2003, 15, 871–882. [CrossRef]
19. Shenoy, M.K.; Shet, K.; Acharya, U.D. A new similarity measure for taxonomy based on edge counting. International Journal of Web & Semantic Technology 2012, 3, 23.
20. Tversky, A. Features of similarity. Psychological review 1977, 84, 327.
21. Lesk, M. Automatic sense disambiguation using machine readable dictionaries: how to tell a pine cone from an ice cream cone. Proceedings of the 5th annual international conference on Systems documentation, 1986, pp. 24–26.
22. Banerjee, S.; Pedersen, T. Extended gloss overlaps as a measure of semantic relatedness. Ijcai. Citeseer, 2003, Vol. 3, pp. 805–810.
23. Jiang, Y.; Zhang, X.; Tang, Y.; Nie, R. Feature-based approaches to semantic similarity assessment of concepts using Wikipedia. Information Processing and Management 2015, 51, 215–234. [CrossRef]
24. Resnik, P. Using Information Content to Evaluate Semantic Similarity in a Taxonomy. CoRR 1995, abs/cmp-lg/9511007, [cmp-lg/9511007].
25. Zhu, G.; Iglesias, C.A. Computing semantic similarity of concepts in knowledge graphs. IEEE Transactions on Knowledge and Data Engineering 2016, 29, 72–85.
26. Jiang, J.J.; Conrath, D.W. Semantic similarity based on corpus statistics and lexical taxonomy. arXiv preprint cmp-lg/9709008 1997.
27. Gao, J.B.; Zhang, B.W.; Chen, X.H. A WordNet-based semantic similarity measurement combining edge-counting and information content theory. Engineering Applications of Artificial Intelligence 2015, 39, 80–88.
28. Jiang, Y.; Bai, W.; Zhang, X.; Hu, J. Wikipedia-based information content and semantic similarity computation. Information Processing & Management 2017, 53, 248–265. [CrossRef]
29. Zhou, Z.; Wang, Y.; Gu, J. A New Model of Information Content for Semantic Similarity in WordNet. 2008 Second International Conference on Future Generation Communication and Networking Symposia, 2008, Vol. 3, pp. 85–89. [CrossRef]
30. Sanchez, D.; Batet, M.; Isern, D. Ontology-based information content computation. Knowledge-Based Systems 2011, 24, 297–303. [CrossRef]
31. Seidel, R. On the All-Pairs-Shortest-Path Problem. Proceedings of the Twenty-Fourth Annual ACM Symposium on Theory of Computing; Association for Computing Machinery: New York, NY, USA, 1992; STOC ’92, pp. 745–749. [CrossRef]
32. Warshall, S. A Theorem on Boolean Matrices. J. ACM 1962, 9, 11–12. [CrossRef]
33. Singh, P.; Kumar, R.; Pandey, V. An Efficient Algorithm for All Pair Shortest Paths. International Journal of Computer and Electrical Engineering 2010, pp. 984–991. [CrossRef]
34. Zwick, U. All Pairs Shortest Paths Using Bridging Sets and Rectangular Matrix Multiplication. J. ACM 2002, 49, 289–317. [CrossRef]
35. D’alberto, P.; Nicolau, A. R-Kleene: A high-performance divide-and-conquer algorithm for the all-pair shortest path for densely connected networks. Algorithmica 2007, 47, 203–213.
36. Islam, M.T.; Thulasiraman, P.; Thulasiram, R.K. A parallel ant colony optimization algorithm for all-pair routing in MANETs. Proceedings International Parallel and Distributed Processing Symposium. IEEE, 2003, pp. 8–pp.
37. Katz, G.J.; Kider, J.T. All-pairs shortest-paths for large graphs on the GPU 2008.
38. Reddy, K.R. A survey of the all-pairs shortest paths problem and its variants in graphs. Acta Universitatis Sapientiae, Informatica 2016, 8. [CrossRef]
39. Aho, A.V.; Hopcroft, J.E. The design and analysis of computer algorithms; Pearson Education India, 1974.
40. Johnson, D.B. Efficient Algorithms for Shortest Paths in Sparse Networks. J. ACM 1977, 24, 1–13. [CrossRef]
41. Chan, T.M. More algorithms for all-pairs shortest paths in weighted graphs. SIAM Journal on Computing 2010, 39, 2075–2089.
42. Peres, Y.; Sotnikov, D.; Sudakov, B.; Zwick, U. All-pairs shortest paths in O (n 2) time with high probability. Journal of the ACM (JACM) 2013, 60, 1–25.
43. Demetrescu, C.; Italiano, G.F. A new approach to dynamic all pairs shortest paths. Journal of the ACM (JACM) 2004, 51, 968–992.
44. Williams, R.R. Faster all-pairs shortest paths via circuit complexity. SIAM Journal on Computing 2018, 47, 1965–1985.
45. Chan, T.M.; Williams, R. Deterministic APSP, orthogonal vectors, and more: Quickly derandomizing Razborov-Smolensky. Proceedings of the twenty-seventh annual ACM-SIAM symposium on Discrete algorithms. SIAM, 2016, pp. 1246–1255.
46. Brodnik, A.; Grgurovic, M. Solving all-pairs shortest path by single-source computations: Theory and practice. Discrete applied mathematics 2017, 231, 119–130.
47. Karger, D.R.; Koller, D.; Phillips, S.J. Finding the hidden path: Time bounds for all-pairs shortest paths. SIAM Journal on Computing 1993, 22, 1199–1217.
48. Kratsch, S.; Nelles, F. Efficient parameterized algorithms for computing all-pairs shortest paths. arXiv preprint arXiv:2001.04908 2020.
49. Yuster, R. Efficient algorithms on sets of permutations, dominance, and real-weighted APSP. Proceedings of the twentieth annual ACM-SIAM symposium on Discrete algorithms. SIAM, 2009, pp. 950–957.
50. Fredman, M.L. New bounds on the complexity of the shortest path problem. SIAM Journal on Computing 1976, 5, 83–89.
51. Takaoka, T. A new upper bound on the complexity of the all pairs shortest path problem. Information Processing Letters 1992, 43, 195–199.
52. Dobosiewicz, W. A more efficient algorithm for the min-plus multiplication. International journal of computer mathematics 1990, 32, 49–60.
53. Han, Y. Improved algorithm for all pairs shortest paths. Information Processing Letters 2004, 91, 245–250.
54. Takaoka, T. A faster algorithm for the all-pairs shortest path problem and its application. International Computing and Combinatorics Conference. Springer, 2004, pp. 278–289.
55. Takaoka, T. An O (n3loglogn/logn) time algorithm for the all-pairs shortest path problem. Information Processing Letters 2005, 96, 155–161.
56. Zwick, U. A slightly improved sub-cubic algorithm for the all pairs shortest paths problem with real edge lengths. International Symposium on Algorithms and Computation. Springer, 2004, pp. 921–932.
57. Chan, T.M. All-pairs shortest paths with real weights in O (n 3/log n) time. Algorithmica 2008, 50, 236–243.
58. Han, Y. An o (n 3 (loglogn/logn) 5/4) time algorithm for all pairs shortest paths. European Symposium on Algorithms. Springer, 2006, pp. 411–417.
59. Attiratanasunthron, N.; Fakcharoenphol, J. A running time analysis of an ant colony optimization algorithm for shortest paths in directed acyclic graphs. Information Processing Letters 2008, 105, 88–92.
60. Neumann, F.; Witt, C. Runtime analysis of a simple ant colony optimization algorithm. International Symposium on Algorithms and Computation. Springer, 2006, pp. 618–627.
61. Di Caro, G.; Dorigo, M. AntNet: Distributed stigmergetic control for communications networks. Journal of Artificial Intelligence Research 1998, 9, 317–365.
62. Horoba, C.; Sudholt, D. Running time analysis of ACO systems for shortest path problems. International Workshop on Engineering Stochastic Local Search Algorithms. Springer, 2009, pp. 76–91.
63. Chou, Y.L.; Romeijn, H.E.; Smith, R.L. Approximating shortest paths in large-scale networks with an application to intelligent transportation systems. INFORMS journal on Computing 1998, 10, 163–179.
64. Mohring, R.H.; Schilling, H.; Schutz, B.; Wagner, D.; Willhalm, T. Partitioning graphs to speedup Dijkstra’s algorithm. Journal of Experimental Algorithmics (JEA) 2007, 11, 2–8.
65. Baswana, S.; Goyal, V.; Sen, S. All-pairs nearly 2-approximate shortest paths in O(n2polylogn) time. Theoretical Computer Science 2009, 410, 84–93. [CrossRef]
66. Yuster, R. Approximate shortest paths in weighted graphs. Journal of Computer and System Sciences 2012, 78, 632–637.
67. Thorup, M.; Zwick, U. Approximate distance oracles. Journal of the ACM (JACM) 2005, 52, 1–24.
68. Das Sarma, A.; Gollapudi, S.; Najork, M.; Panigrahy, R. A sketch-based distance oracle for web-scale graphs. Proceedings of the third ACM international conference on Web search and data mining, 2010, pp. 401–410.
69. Wang, Y.; Wang, Q.; Koehler, H.; Lin, Y. Query-by-Sketch: Scaling Shortest Path Graph Queries on Very Large Networks. Proceedings of the 2021 International Conference on Management of Data, 2021, pp. 1946–1958.
70. Akiba, T.; Iwata, Y.; Yoshida, Y. Fast exact shortest-path distance queries on large networks by pruned landmark labeling. Proceedings of the 2013 ACM SIGMOD International Conference on Management of Data, 2013, pp. 349–360.
71. Mendiola, E. Algoritmo para el cálculo acelerado de distancias conceptuales. PhD thesis, Instituto Politécnico Nacional, Mexico City, 2022.
72. Cohen, E.; Halperin, E.; Kaplan, H.; Zwick, U. Reachability and distance queries via 2-hop labels. SIAM Journal on Computing 2003, 32, 1338–1355.
73. Robertson, N.; Seymour, P. Graph minors. III. Planar tree-width. Journal of Combinatorial Theory, Series B 1984, 36, 49–64. [CrossRef]
74. Miller, G.A.; Charles, W.G. Contextual correlates of semantic similarity. Language and cognitive processes 1991, 6, 1–28.
75. Rubenstein, H.; Goodenough, J.B. Contextual correlates of synonymy. Communications of the ACM 1965, 8, 627–633.
76. Pirro, G. A semantic similarity metric combining features and intrinsic information content. Data & Knowledge Engineering 2009, 68, 1289–1308.
77. Agirre, E.; Alfonseca, E.; Hall, K.; Kravalova, J.; Pasca, M.; Soroa, A. A study on similarity and relatedness using distributional and wordnet-based approaches 2009.
78. Hill, F.; Reichart, R.; Korhonen, A. Simlex-999: Evaluating semantic models with (genuine) similarity estimation. Computational Linguistics 2015, 41, 665–695.
79. Halawi, G.; Dror, G.; Gabrilovich, E.; Koren, Y. Large-scale learning of word relatedness with constraints. Proceedings of the 18th ACM SIGKDD international conference on Knowledge discovery and data mining, 2012, pp. 1406–1414.
80. Radinsky, K.; Agichtein, E.; Gabrilovich, E.; Markovitch, S. A word at a time: computing word relatedness using temporal semantic analysis. Proceedings of the 20th international conference on World wide web, 2011, pp. 337–346.
81. Finkelstein, L.; Gabrilovich, E.; Matias, Y.; Rivlin, E.; Solan, Z.; Wolfman, G.; Ruppin, E. Placing search in context: The concept revisited. Proceedings of the 10th international conference on World Wide Web, 2001, pp. 406–414.
82. Szumlanski, S.; Gomez, F.; Sims, V.K. A new set of norms for semantic relatedness measures. Proceedings of the 51st Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers), 2013, pp. 890–895.
83. Huang, E.H.; Socher, R.; Manning, C.D.; Ng, A.Y. Improving word representations via global context and multiple word prototypes. Proceedings of the 50th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 2012, pp. 873–882.