All-pairs Shortest Paths Research Articles

Cluster of Optimal Chains of All-Pairs Shortest Paths to Deduce Minimum Cost Tour

This paper aims at analyzing all-pairs shortest paths algorithm by Floyd to extract optimal path between any pair of vertices of various path length. To form least cost round tour, vertices of an optimal chain are grouped into cluster. These optimal chains are combined by taking an account of both path length as well as magnitude of the path. The chain which has largest path length and optimal distance will be considered first. Tour is constructed by adding up vertices to optimal chains in suitable positions based on nearness. This approach is a mix of both dynamic and greedy strategies. Illustrations of different variations are focus of the study. Keywords:Cost Adjacency Matrix, Optimal Chain, Round tour, Path length matrix, predecessor matrix and all-pairs shortest paths

Solving all-pairs shortest path by single-source computations: Theory and practice

Given an arbitrary directed graph G=(V,E) with non-negative edge lengths, we present an algorithm that computes all pairs shortest paths in time O(m∗n+mlgn+nTψ(m∗,n)), where m∗ is the number of different edges contained in shortest paths and Tψ(m∗,n) is the running time of an algorithm ψ solving the single-source shortest path problem (SSSP). This is a substantial improvement over a trivial n times application of ψ that runs in O(nTψ(m,n)). In our algorithm we use ψ as a black box and hence any improvement on ψ results also in improvement of our algorithm. A combination of our method, Johnson’s reweighting technique and topological sorting results in an O(m∗n+mlgn) all-pairs shortest path algorithm for directed acyclic graphs with arbitrary edge lengths. We also point out a connection between the complexity of a certain sorting problem defined on shortest paths and SSSP. Finally, we show how to improve the performance of the proposed algorithm in practice. We then empirically measure the running times of various all-pairs shortest path algorithms on randomly generated graph instances and obtain very promising results.

Advances of prevalence and risk factors of chronic postsurgical pain

Background Acute post-surgical pain(APSP) is a common complication following various surgeries, some of which return to normal instantly, while others will translate to chronic post-surgical pain(CPSP). The prevalence is variable, serious in some studies, and there are no effective preventive measures and therapy methods. Objective It is very important to reinforce the understanding of CPSP, to establish effective preventive measures, and to optimize the treatment methods treatment and improving the outcome. Content This review describes the prevalence, the risk factors, the preventive measures and the treatment methods of CPSP. Trend With the progress of the research on CPSP, optimization of the preventive measures and treatment methods will benefit the patients. Key words: Postoperative pain; Chronic; Epidemiologic measurements; Risk factors

Analysis of classic algorithms on highly-threaded many-core architectures

The recently developed Threaded Many-core Memory (TMM) model provides a framework for analyzing algorithms for highly-threaded many-core machines such as GPUs and Cray supercomputers. In particular, it tries to capture the fact that these machines hide memory latencies via the use of a large number of threads and large memory bandwidth. The TMM model analysis contains two components: computational and memory complexity.A model is only useful if it can explain and predict empirical data. In this work, we investigate the effectiveness of the TMM model. Under this model, we analyze algorithms for 5 classic problems— suffix tree/array for string matching, fast Fourier transform, merge sort, list ranking, and all-pairs shortest paths—on a variety of GPUs. We also analyze memory access, matrix multiply and a sequence alignment algorithm on a set of Cray XMT supercomputers, the latest NVIDIA and AMD GPUs. We compare the results of the analysis with the experimental findings of ours and other researchers who have implemented and measured the performance of these algorithms on a spectrum of diverse GPUs and Cray appliances. We find that the TMM model is able to predict important, non-trivial, and sometimes previously unexplained trends and artifacts in the experimental data.

Morphological characterization and HSP70-, IGS-based phylogenetic analysis of two microsporidian parasites isolated from Antheraea pernyi.

Two microsporidian isolates were extracted from single infected egg-laying tussah silk moth (Antheraea pernyi) in Liaoning Province, China. The microsporidia were subsequently grown in silk moth larvae, isolated, and subjected to morphological characterization (by light and transmission electron microscopy) and phylogenetic analysis (based on conserved genes). One type of spore was long-axis-oval in shape, measuring 4.71×1.95μm, and the other type was short-axis-oval, measuring 3.64×2.17μm. These dimensions were markedly different from those reported in the spores of the common microsporidia infecting A. pernyi, namely, Nosema pernyi (4.36×1.49μm). A neighbor-joining phylogenetic tree based on HSP70 indicated that these microsporidia belonged to Nosema species and were closely related with Nosema bombycis and Nosema ceranae. Furthermore, in the phylogenetic tree based on the intergenic spacer (IGS) region, the long-axis-oval isolates were closely related and tended to form a clade away from the short-axis-oval isolates and N. pernyi isolates. The microsporidia isolated from A. pernyi clustered in one group. Nosema bombycis, Nosema spodopterae, and Endoreticulatus spp. appeared to be genetically distant from N. pernyi. The two isolates from A. pernyi fell in the Nosema group, but their spores differed from those of the spores of the common A. pernyi parasite N. pernyi, both in morphological and genetic aspects. The two isolates were designated Nosema sp. Ap (L) and Nosema sp. Ap (S). IGS was found to be informative in ascertaining phylogenetic relationships among species, and even closely related strains, of microsporidia.

On the Shoshan-Zwick Algorithm for the All-Pairs Shortest Path Problem

The Shoshan-Zwick algorithm solves the all-pairs shortest paths problem in undirected graphs with integer edge costs in the range $\{1, 2, \dots, M\}$. It runs in $\tilde{O}(M\cdot n^{\omega})$ time, where $n$ is the number of vertices, $M$ is the largest integer edge cost, and $\omega < 2.3727$ is the exponent of matrix multiplication. It is the fastest known algorithm for this problem. This paper points out and corrects an error in the Shoshan-Zwick algorithm.

All-Pairs Shortest Paths Algorithm for Regular 2D Mesh Topologies

All-Pairs Shortest Paths Algorithm for Regular 2D Mesh Topologies

A survey of the all-pairs shortest paths problem and its variants in graphs

Abstract There has been a great deal of interest in the computation of distances and shortest paths problem in graphs which is one of the central, and most studied, problems in (algorithmic) graph theory. In this paper, we survey the exact results of the static version of the all-pairs shortest paths problem and its variants namely, the Wiener index, the average distance, and the minimum average distance spanning tree (MAD tree in short) in graphs (focusing mainly on algorithmic results for such problems). Along the way we also mention some important open issues and further research directions in these areas.

A new algorithm for generation of dispatchable networks with temporal constraints

ABSTRACTIn most real-world planning domains, it is important to have flexible executive time against uncertainty and disturbance of environment. Execution time can be propagated from dispatchable Simple Temporal Network (STN), which is obtained from filtering the distance graph of STN. To minimise the execution latency, computation of dispatchable STN should be improved. In the previous works, all-pairs shortest paths (APSP) algorithm is used to compute distance graph of STN, so the redundant constraints should be processed in the following filtering process. In this paper, an improved algorithm named Dispatchabile Partial Path (DPP) algorithm, which uses the P3C algorithm to replace APSP and compute the shortest distance of vertices, is presented. To ensure the correctness of dispatchable STN, triangulation uses vertices ordering sorted by execute time. The filtering process is also simplified by time-sorting vertices. Experimental evidence confirms that the DPP algorithm outperforms previous algorithms based on APSP.

Parallel All-Pairs Shortest Path Algorithm: Network Decomposition Approach

The all-pairs shortest path algorithms compute the shortest paths between all node pairs in a network. This paper presents a parallel algorithm for the all-pairs shortest path problem with a network decomposition approach. The algorithm decomposes the network into a set of independent augmented directed acyclic subnetworks that can be efficiently processed in parallel. The shortest path computation for each subnetwork provides a subset of the all-pairs shortest paths in the original network. The superiority of the new algorithm was verified through comparing its performance against that of the parallel single-origin shortest path algorithm. The execution times were compared for hypothetical and real-world networks with different sizes. A percentage of improvement in the execution time of about 50% was recorded for the transportation network of a large metropolitan area.

Dynamic Approximate All-Pairs Shortest Paths: Breaking the $O(mn)$ Barrier and Derandomization

We study dynamic $(1+\epsilon)$-approximation algorithms for the all-pairs shortest paths problem in unweighted undirected $n$-node $m$-edge graphs under edge deletions. The fastest algorithm for this problem is a randomized algorithm with a total update time of $\tilde O(mn/\epsilon)$ and constant query time by Roditty and Zwick [FOCS 2004]. The fastest deterministic algorithm is from a 1981 paper by Even and Shiloach [JACM 1981]; it has a total update time of $O(mn^2)$ and constant query time. We improve these results as follows: (1) We present an algorithm with a total update time of $\tilde O(n^{5/2}/\epsilon)$ and constant query time that has an additive error of $2$ in addition to the $1+\epsilon$ multiplicative error. This beats the previous $\tilde O(mn/\epsilon)$ time when $m=\Omega(n^{3/2})$. Note that the additive error is unavoidable since, even in the static case, an $O(n^{3-\delta})$-time (a so-called truly subcubic) combinatorial algorithm with $1+\epsilon$ multiplicative error cannot have an additive error less than $2-\epsilon$, unless we make a major breakthrough for Boolean matrix multiplication [Dor et al. FOCS 1996] and many other long-standing problems [Vassilevska Williams and Williams FOCS 2010]. The algorithm can also be turned into a $(2+\epsilon)$-approximation algorithm (without an additive error) with the same time guarantees, improving the recent $(3+\epsilon)$-approximation algorithm with $\tilde O(n^{5/2+O(\sqrt{\log{(1/\epsilon)}/\log n})})$ running time of Bernstein and Roditty [SODA 2011] in terms of both approximation and time guarantees. (2) We present a deterministic algorithm with a total update time of $\tilde O(mn/\epsilon)$ and a query time of $O(\log\log n)$. The algorithm has a multiplicative error of $1+\epsilon$ and gives the first improved deterministic algorithm since 1981. It also answers an open question raised by Bernstein [STOC 2013].

Maintaining Shortest Paths Under Deletions in Weighted Directed Graphs

We present an improved algorithm for maintaining all-pairs $(1 + \epsilon)$ approximate shortest paths under deletions and weight-increases. The previous state of the art for this problem is total update time $\widetilde{O}(n^2\sqrt{m}/\epsilon)$ over all updates for directed unweighted graphs [S. Baswana, R. Hariharan, and S. Sen, J. Algorithms, 62 (2007), pp. 74--92], and $\widetilde{O}(mn/\epsilon)$ for undirected unweighted graphs [L. Roditty and U. Zwick, in Proceedings of the 45th FOCS, Rome, Italy, 2004, pp. 499--508]. Both algorithms are randomized and have constant query time. Very recently, Henzinger, Krinninger, and Nanongkai presented a deterministic version of the latter algorithm [M. Henzinger, S. Krinninger, and D. Nanongkai, in IEEE FOCS, 2013, pp. 538--547]. Note that $\widetilde{O}(mn)$ is a natural barrier because even with a $(1 + \epsilon)$ approximation, there is no $o(mn)$ combinatorial algorithm for the static all-pairs shortest path problem. Our algorithm works on directed weighte...

Comparative Analysis of Floyd Warshall and Dijkstras Algorithm using Opencl

Shortest path algorithms finds applications in large real world domains. All pair shortest path (APSP) and single source shortest path (SSSP) both have their special applications domains. All though every SSSP can be applied for all vertices to calculate APSP. But APSP cant. In this paper heterogeneous implementation of Floyd warshalls algorithm and Dijkstra’s algorithm is compared on dense graphs have positive edge weights ranging from 1 to 10. It is found that Dijkstra’s algorithm is better than Floyd warshall algorithm in sequencial implementation. But as there is less parallelism identified in dijkstra algorithm as compared to parallel to parallel FW gives less execution time as compared to Dijkstra’s.

Resilient Dynamic Programming

We investigate the design of dynamic programming algorithms in unreliable memories, i.e., in the presence of errors that lead the logical state of some bits to be read differently from how they were last written. Assuming that a limited number of memory faults can be inserted at run-time by an adversary with unbounded computational power, we obtain the first resilient algorithms for a broad range of dynamic programming problems, devising a general framework that can be applied to both iterative and recursive implementations. Besides all local dependency problems, where updates to table entries are determined by the contents of neighboring cells, we also settle challenging non-local problems, such as all-pairs shortest paths and matrix multiplication. All our algorithms are correct with high probability and match the running time of their standard non-resilient counterparts while tolerating a polynomial number of faults. The recursive algorithms are also cache-efficient and can tolerate faults at any level of the memory hierarchy. Our results exploit a careful combination of data replication, majority techniques, fingerprint computations, and lazy fault detection. To cope with the complex data access patterns induced by some of our algorithms, we also devise amplified fingerprints, which might be of independent interest in the design of resilient algorithms for different problems.

Interval-based performance modeling for the all-pairs-shortest-path problem on GPUs

The article proposes a cost model for two implementations of the all-pairs-shortest-path (APSP) problem on graphics processing units (GPUs) with a particular focus on the correct reproduction of the shape of the runtime curve for different input problem sizes and thread block configurations. The model categorizes thread blocks according to the number of active warps and defines four different approaches to estimate the mapping of thread blocks to the hardware execution resources. Each of these approaches leads to a runtime prediction, which together span an interval for the expected execution time. An experimental evaluation shows that most characteristics of the runtime curve are predicted correctly, which is especially important for small graphs where a tiny increase of the input size may result in a significant increase of the execution time. For large graphs, we show that the cost prediction deviates less than 1 % from the measured times in many cases.

All-Pairs Shortest Path algorithms for planar graph for GPU-accelerated clusters

We present a new approach for solving the All-Pairs Shortest-Path (APSP) problem for planar graphs that exploits the massive on-chip parallelism available in today’s Graphics Processing Units (GPUs). We describe two new algorithms based on our approach. Both algorithms use Floyd–Warshall method, have near optimal complexity in terms of the total number of operations, while their matrix-based structure is regular enough to allow for efficient parallel implementation on the GPUs. By applying a divide-and-conquer approach, we are able to make use of multi-node GPU clusters, resulting in more than an order of magnitude speedup over fastest known Dijkstra-based GPU implementation and a two-fold speedup over a parallel Dijkstra-based CPU implementation.

A Fast Numerical Method for Max-Convolution and the Application to Efficient Max-Product Inference in Bayesian Networks.

Observations depending on sums of random variables are common throughout many fields; however, no efficient solution is currently known for performing max-product inference on these sums of general discrete distributions (max-product inference can be used to obtain maximum a posteriori estimates). The limiting step to max-product inference is the max-convolution problem (sometimes presented in log-transformed form and denoted as "infimal convolution," "min-convolution," or "convolution on the tropical semiring"), for which no O(k log(k)) method is currently known. Presented here is an O(k log(k)) numerical method for estimating the max-convolution of two nonnegative vectors (e.g., two probability mass functions), where k is the length of the larger vector. This numerical max-convolution method is then demonstrated by performing fast max-product inference on a convolution tree, a data structure for performing fast inference given information on the sum of n discrete random variables in O(nk log(nk)log(n)) steps (where each random variable has an arbitrary prior distribution on k contiguous possible states). The numerical max-convolution method can be applied to specialized classes of hidden Markov models to reduce the runtime of computing the Viterbi path from nk(2) to nk log(k), and has potential application to the all-pairs shortest paths problem.

SPLZ: An efficient algorithm for single source shortest path problem using compression method

Efficient solution of the single source shortest path (SSSP) problem on road networks is an important requirement for numerous real-world applications. This paper introduces an algorithm for the SSSP problem using compression method. Owning to precomputing and storing all-pairs shortest path (APSP), the process of solving SSSP problem is a simple lookup of a little data from precomputed APSP and decompression. APSP without compression needs at least 1TB memory for a road network with one million vertices. Our algorithm can compress such an APSP into several GB, and ensure a good performance of decompression. In our experiment on a dataset about Northwest USA (with 1.2 millions vertices), our method can achieve about three orders of magnitude faster than Dijkstra algorithm based on binary heap.

Distance closures on complex networks

AbstractTo expand the toolbox available to network science, we study the isomorphism between distance and Fuzzy (proximity or strength) graphs. Distinct transitive closures in Fuzzy graphs lead to closures of their isomorphic distance graphs with widely different structural properties. For instance, the All Pairs Shortest Paths (APSP) problem, based on the Dijkstra algorithm, is equivalent to a metric closure, which is only one of the possible ways to calculate shortest paths in weighted graphs. We show that different closures lead to different distortions of the original topology of weighted graphs. Therefore, complex network analyses that depend on the calculation of shortest paths on weighted graphs should take into account the closure choice and associated topological distortion. We characterize the isomorphism using the max-min and Dombi disjunction/conjunction pairs. This allows us to: (1) study alternative distance closures, such as those based on diffusion, metric, and ultra-metric distances; (2) identify the operators closest to the metric closure of distance graphs (the APSP), but which are logically consistent; and (3) propose a simple method to compute alternative path length measures and corresponding distance closures using existing algorithms for the APSP. In particular, we show that a specific diffusion distance is promising for community detection in complex networks, and is based on desirable axioms for logical inference or approximate reasoning on networks; it also provides a simple algebraic means to compute diffusion processes on networks. Based on these results, we argue that choosing different distance closures can lead to different conclusions about indirect associations on network data, as well as the structure of complex networks, and are thus important to consider.

Cache-oblivious wavefront: improving parallelism of recursive dynamic programming algorithms without losing cache-efficiency

State-of-the-art cache-oblivious parallel algorithms for dynamic programming (DP) problems usually guarantee asymptotically optimal cache performance without any tuning of cache parameters, but they often fail to exploit the theoretically best parallelism at the same time. While these algorithms achieve cache-optimality through the use of a recursive divide-and-conquer (DAC) strategy, scheduling tasks at the granularity of task dependency introduces artificial dependencies in addition to those arising from the defining recurrence equations. We removed the artificial dependency by scheduling tasks ready for execution as soon as all its real dependency constraints are satisfied, while preserving the cache-optimality by inheriting the DAC strategy. We applied our approach to a set of widely known dynamic programming problems, such as Floyd-Warshall's All-Pairs Shortest Paths, Stencil, and LCS. Theoretical analyses show that our techniques improve the span of 2-way DAC-based Floyd Warshall's algorithm on an $n$ node graph from $Thn^2n$ to $Thn$, stencil computations on a $d$-dimensional hypercubic grid of width $w$ for $h$ time steps from $Th(d^2 h) w^ (d+2) - 1$ to $Thh$, and LCS on two sequences of length $n$ each from $Thn^_2 3$ to $Thn$. In each case, the total work and cache complexity remain asymptotically optimal. Experimental measurements exhibit a $3$ - $5$ times improvement in absolute running time, $10$ - $20$ times improvement in burdened span by Cilkview, and approximately the same L1/L2 cache misses by PAPI.