All-pairs Shortest Path Problem Research Articles

Speeding up the Passenger Assignment Problem in transit planning by the Direct Link Network representation

When designing a public transport network with the passenger travel time in mind, the passenger assignment problem (PAP) needs to be addressed explicitly. It is a complex problem on its own and even the simplest version requires determination of the shortest path for all demand pairs in the network. It is typically treated as a subproblem of larger problems by public transport planners, such as the transit network design problem (TNDP). In the TNDP, bi-level optimization models and/or metaheuristics are used where the PAP is solved when evaluating a line plan. In doing so, the PAP is often addressed by representing the transit network with a so-called ‘Change-and-Go’ (CNG) network with dummy transfer nodes in order to model transfer penalties as part of the passenger travel time. Then, in order to solve the PAP, the all-pairs shortest path problem needs to be solved for this CNG network representation. In this paper, we present a much more efficient network representation, ‘Direct Link Network’ (DLN), where additional edges are added instead of additional nodes. We compare the theoretical complexity of both representations and the computation time required to solve the PAP by using CNG and DLN on the most commonly used benchmark networks and also several real-life networks. The results show that with the DLN representation, the PAP can be solved multiple times faster than with CNG. Consequently, DLN can significantly speed up all TNDP algorithms that solve the PAP multiple times when designing a public transport network.

Tuning block-parallel all-pairs shortest path algorithm for efficient multi-core implementa- tion.

Finding shortest paths in a weighted graph is one of the key problems in computer-science, which has numerous practical applications in multiple domains. This paper analyzes the parallel blocked all-pairs shortest path algorithm at the aim of evaluating the influence of the multi-core system and its hierarchical cache memory on the parameters of algorithm implementation depending on the size of the graph and the size of distance matrix’s block. It proposes a technique of tuning the block-size to the given multi-core system. The technique involves profiling tools in the tuning process and allows the increase of the parallel algorithm throughput. Computational experiments carried out on a rack server equipped with two Intel Xeon E5-2620 v4 processors of 8 cores and 16 hardware threads each have convincingly shown for various graph sizes that the behavior and parameters of the hierarchical cache memory operation don’t depend on the graph size and are determined only by the distance matrix’s block size. To tune the algorithm to the target multi-core system, the preferable block size can be found once for the graph size whose in-memory matrix representation is larger than the size of cache shared among all processor’s cores. Then this blocksize can be reused on graphs of bigger size for efficient solving the all-pairs shortest path problem

Exponentially Faster Shortest Paths in the Congested Clique

We present improved deterministic algorithms for approximating shortest paths in the Congested Clique model of distributed computing. We obtain poly(log log n )-round algorithms for the following problems in unweighted undirected n -vertex graphs: ( 1 + ϵ )-approximation of multi-source shortest paths (MSSP) from O (√ n ) sources. (2 + ϵ )-approximation of all pairs shortest paths (APSP). (1 + ϵ , β)-approximation of APSP where β = O (log log n / ϵ ) log log n . These bounds improve exponentially over the state-of-the-art poly-logarithmic bounds due to [Censor-Hillel et al., PODC19]. It also provides the first nearly-additive bounds for the APSP problem in sub-polynomial time. Our approach is based on distinguishing between short and long distances based on some distance threshold t = O ( β / ϵ ) where β = O (log log n / ϵ ) log log n . Handling the long distances is done by devising a new algorithm for computing a sparse (1 + ϵ , β ) emulator with O ( n log log n ) edges. For the short distances, we provide distance-sensitive variants for the distance tool-kit of [Censor-Hillel et al., PODC19]. By exploiting the fact that this tool-kit should be applied only on local balls of radius t , their round complexities get improved from poly (log n ) to poly (log t ). Finally, our deterministic solutions for these problems are based on a derandomization scheme of a novel variant of the hitting set problem, which might be of independent interest.

Visual Analysis of Neural Architecture Spaces for Summarizing Design Principles.

Recent advances in artificial intelligence largely benefit from better neural network architectures. These architectures are a product of a costly process of trial-and-error. To ease this process, we develop ArchExplorer, a visual analysis method for understanding a neural architecture space and summarizing design principles. The key idea behind our method is to make the architecture space explainable by exploiting structural distances between architectures. We formulate the pairwise distance calculation as solving an all-pairs shortest path problem. To improve efficiency, we decompose this problem into a set of single-source shortest path problems. The time complexity is reduced from O(kn2N) to O(knN). Architectures are hierarchically clustered according to the distances between them. A circle-packing-based architecture visualization has been developed to convey both the global relationships between clusters and local neighborhoods of the architectures in each cluster. Two case studies and a post-analysis are presented to demonstrate the effectiveness of ArchExplorer in summarizing design principles and selecting better-performing architectures.

A novel approach for solving all-pairs shortest path problem in an interval-valued fuzzy network: Suggested modifications

Enayattabr et al. (Journal of Intelligent and Fuzzy Systems 37 (2019) 6865– 6877) claimed that till now no one has proposed an approach to solve interval-valued trapezoidal fuzzy all-pairs shortest path problems (all-pairs shortest path problems in which distance between every two nodes is represented by an interval-valued trapezoidal fuzzy number). Also, to fill this gap, Enayattabr et al. proposed an approach to solve interval-valued trapezoidal fuzzy all-pairs shortest path problems. In this paper, an interval-valued trapezoidal fuzzy shortest path problem is considered to point out that Enayattabr et al.’s approach fails to find correct shortest distance between two fixed nodes. Hence, it is inappropriate to use Enayattabr et al.’s approach in its present from. Also, the required modifications are suggested to resolve this inappropriateness of Enayattabr et al.’s approach.

SIGEST

The SIGEST article in this issue is “From Circuit Complexity to Faster All-Pairs Shortest Paths,” by R. Ryan Williams. The original paper appeared in SIAM Journal on Computing (SICOMP) in 2018 and, as indicated by the high citation count, ideas from this work have inspired a broad range of future activity. For a given $n$-node graph, the problem tackled here is to compute all shortest paths between any pair of nodes, the so-called all-pairs shortest path (APSP) problem. As explained by the author (see Corollary 1.2) a solution to the APSP problem leads to solutions for many other problems in discrete mathematics. The key result in this work is a new algorithm that improves on the classical $O(n^3)$ complexity for the first time by a factor that is superpolylogarithmic. This is done by introducing a new technique, called the polynomial method. Key ingredients of the work are the use of tropical, or max-plus, algebra, where $\min$ plays the role of addition and $+$ is promoted to multiplication, and a new reduction to rectangular matrix multiplication over the field of two elements. In addition to creating an algorithm that runs faster than $n^3/\log^k n$ for every constant $k$, the author discusses the potential for achieving a truly subcubic speed of $n^{3-\epsilon}$ for some $\epsilon >0$. The original (SICOMP) article has been given an extended introduction to increase accessibility to the SIAM readership. Thanks to the wide applicability of the APSP problem, and the potential for further developments in the field, this paper should be of interest both to researchers working on algorithms and to those working on complexity.

Consequences of APSP, triangle detection, and 3SUM hardness for separation between determinism and non-determinism

Let NDTIME(f(n),g(n)) denote the class of problems solvable in O(g(n)) time by a multi-tape Turing machine using an f(n)-bit non-deterministic oracle, and let DTIME(g(n)) = NDTIME(0, g(n)). We show that if the all-pairs shortest paths problem (APSP) for directed graphs with N vertices and integer edge weights within a super-exponential range { −2Nk+o(1),....,2Nk+o(1) }, k≥1 does not admit a truly subcubic algorithm then for any ∈>0, NDTIME([ 1/2 log2 n ], n)⊆DTIME(n1+12+k−∈). If the APSP problem does not admit a truly subcubic algorithm already when the edge weights are of moderate size then we obtain an even stronger implication, namely that for any ∈>0, NDTIME([ 1/2 log2 n ], n)⊆DTIME(n1.5−∈). Similarly, we show that if the triangle detection problem (DT) in a graph on N vertices does not admit a truly sub-Nω -time algorithm then for any ∈>0, NDTIME([ 1/2 log2 n ], n)⊆DTIME(nw/2−∈), where ω stands for the exponent of fast matrix multiplication. For the more general problem of detecting a minimum weight ℓ-clique (MWCℓ) in a graph with edge weights of moderate size, we show that the non-existence of truly sub−Nℓ−time algorithm yields for any ∈>0, NDTIME((ℓ−2)[ 12 log2n ],n)⊆DTIME(n1+ℓ−22−∈). Next, we show that if 3SUM for N integers in { −2Nk+o(1),....2Nk+o(1) } for some k≥0, does not admit a truly subquadratic algorithm then for any ∈>0, NDTIME([ log2n ],n)⊆DTIME(n1+11+k−∈). Finally, we observe that the Exponential Time Hypothesis (ETH) implies NDTIME([ k log2n ],n)⊆DTIME(n) for some k>0, while the strong ETH (SETH) yields for any ∈>0, NDTIME([ log2n ],n)⊆DTIME(n2−ε). For comparison, the strongest known result on separation between non-deterministic and deterministic time only asserts NDTIME(O(n),n)⊆DTIME(n).

From Circuit Complexity to Faster All-Pairs Shortest Paths

We present a randomized method for computing the min-plus product (a.k.a. tropical product) of two $n \times n$ matrices, yielding a faster algorithm for solving the all-pairs shortest path problem (APSP) in dense $n$-node directed graphs with arbitrary edge weights. In the real random-access machine model, where additions and comparisons of reals are unit cost (but all other operations have logarithmic cost), the algorithm runs in time $\frac{n^3}{2^{\Omega(\log n)^{1/2}}}$ and is correct with high probability. On the word random-access machine which permits constant-time operations on $\log(n)$-bit words, the algorithm runs in $n^3/2^{\Omega(\log n)^{1/2}} + n^{2+o(1)}\log(nM)$ time on graphs with edge weights in $([0,M] \cap \mathbb{Z})\cup\{\infty\}$. Prior algorithms needed either $\Theta(n^3/\log^c n)$ time for various $c \leq 2$, or $\Theta(M^{\alpha}n^{\beta})$ time for various $\alpha > 0$ and $\beta > 2$. Our algorithm applies a tool from circuit complexity, namely, the Razborov--Smolensky polynomials for approximately representing ${AC}^0[p]$ circuits, to efficiently reduce a matrix product over the min-plus algebra to a relatively small number of rectangular matrix products over $\mathbb{F}_2$. Each rectangular matrix product can be computed using a particularly efficient method due to Coppersmith. We also give a deterministic version of the algorithm running in $n^3/2^{\log^{\delta} n}$ time for some $\delta > 0$, which utilizes the Yao--Beigel--Tarui translation of ${AC}^0[m]$ circuits into “nice” depth-two circuits.

Faster Replacement Paths and Distance Sensitivity Oracles

Shortest paths computation is one of the most fundamental problems in computer science. An important variant of the problem is when edges can fail, and one needs to compute shortest paths that avoid a (failing) edge. More formally, given a source node s , a target node t , and an edge e , a replacement path for the triple ( s , t , e ) is a shortest s - t path avoiding edge e . Replacement paths computation can be seen either as a static problem or as a data structure problem. In the static setting, a typical goal is to compute for fixed s and t , for every possible failed edge e , the length of the best replacement path around e ( replacement paths problem ). In the data structure setting, a typical goal is to design a data structure ( distance sensitivity oracle ) that, after some preprocessing, quickly answers queries of the form: What is the length of the replacement path for the triple ( s , t , e )? In this article, we focus on n -node directed graphs with integer edge weights in [− M , M ], and present improved replacement paths algorithms and distance sensitivity oracles based on fast matrix multiplication. In more detail, we obtain the following main results: • We describe a replacement paths algorithm with runtime Õ( Mn ω ), where ω < 2.373 is the fast matrix multiplication exponent. For a comparison, the previous fastest algorithms have runtime õ( Mn 1+2ω /3 ) [Weimann,Yuster—FOCS’10] and, in the unweighted case, õ( n 2.5 ) [Roditty, Zwick—ICALP’05]. Our result shows that, at least for small integer weights, the replacement paths problem in directed graphs may be easier than the related all-pairs shortest paths problem, as the current best runtime for the latter is õ( M 1\4−ω n 2+1 \ 4−ω ): this is Ω ( n 2.5 ) even if ω = 2. Our algorithm also implies that the k shortest simple s - t paths can be computed in õ( kMn ω ) time. • We consider the single-source generalization of the replacement paths problem, where only the source s is fixed. We show how to solve this problem in all-pairs shortest paths time, currently õ( M 1\4−ω n 2+1\4−ω ). Our runtime reduces to õ( Mn ω ) for positive weights, hence matching our mentioned result for the simpler replacement paths case (that, however, holds also for nonpositive weights). One of the ingredients that we use is an algorithm to compute the distances from a set s of source nodes to a set T of target nodes in õ( Mn ω +| S |ṡ | T |ṡ ( Mn ) 1\4−ω ) time. This improves on a result in Yuster,Zwick—FOCS’05. • We present the first distance sensitivity oracle that achieves simultaneously subcubic preprocessing time and sublinear query time. More precisely, for a given parameter α ∈ [0,1], our oracle has preprocessing time Õ( Mn ω + 1\ 2 + Mn ω + α (4−ω) ) and query time Õ( n 1−&alpha ). The previous best oracle for small integer weights has Õ( Mn ω +1−α ) preprocessing time and (superlinear) Õ( n 1+α ) query time [Weimann,Yuster-FOCS’10]. From a technical point of view, an interesting and novel aspect of our oracle is that it exploits as a subroutine our single-source replacement paths algorithm. We also present an oracle with the same preprocessing time as in Weimann,Yuster—FOCS’10 and with smaller query time õ( n 1−1−α\4−ω + n 2α ).

A novel approach for solving all-pairs shortest path problem in an interval-valued fuzzy network

A novel approach for solving all-pairs shortest path problem in an interval-valued fuzzy network

Solving the Nearly Symmetric All-Pairs Shortest-Path Problem

We introduce a simple modification to the repeated shortest-path algorithm for the all-pairs shortest-path problem that adds a cumulative distance label update at each iteration based on the shorte...

Sufficient and necessary conditions for solution finding in valuation-based systems

Valuation algebras abstract a large number of formalisms for automated reasoning and enable the definition of generic inference procedures. Many of these formalisms provide some notion of solution. Typical examples are satisfying assignments in constraint systems, models in logics or solutions to linear equation systems.Dynamic programming algorithms rely on low treewidth decompositions and can be understood as particular cases of a single algorithmic scheme for finding solutions in a valuation algebra. The most encompassing description of this algorithmic scheme to date has been proposed by Pouly and Kohlas together with sufficient conditions for its correctness. Unfortunately, the formalization relies on a theorem for which we provide a counterexample. In spite of that, the mainline of Pouly and Kohlas' theory is correct, although some of the necessary conditions have to be revised. In this paper we analyze the impact that the counterexample has on the theory, and rebuild the theory providing correct sufficient conditions for the algorithms. Furthermore, we also provide necessary conditions for the algorithms, allowing for a sharper characterization of when the algorithmic scheme can be applied.The contribution of the paper is not limited to correcting Pouly and Kohlas' theory. First, we generalize their results from discrete tuples to tuple systems. This allows us to cover some classical algorithms, such as sparse Cholesky factorization, as well as more recently proposed algorithms, such as Snowball (sparse all-pairs shortest path problems), as particular cases of the generic valuation-based algorithms presented here.For the particular case of valuation algebras induced by selective semirings, Pouly and Kohlas presented an algorithm for finding all solutions without requiring any additional condition for correctness. We characterize a necessary and a sufficient condition for it. Furthermore, we also introduce a new algorithm that requires no necessary condition.

All-pairs shortest paths in geometric intersection graphs

$\newcommand{\OO}[1]{O\left(#1\right)}$We present a simple and general algorithm for the all-pairs shortest paths (APSP) problem in unweighted geometric intersection graphs. Specifically we reduce the problem to the design of static data structures for offline intersection detection. Consequently we can solve APSP in unweighted intersection graphs of $n$ arbitrary disks in $\OO{n^2 \log n}$ time, axis-aligned line segments in $\OO{n^2 \log{\log n}}$ time, arbitrary line segments in $\OO{n^{7/3} \log^{1/3} n}$ time, $d$-dimensional axis-aligned unit hypercubes in $\OO{n^2 \log\log n}$ time for $d=3$ and $\OO{n^2 \log^{d-3} n}$ time for $d\geq4$, and $d$-dimensional axis-aligned boxes in $\OO{n^2 \log^{d-1.5} n}$ time for $d\geq2$. We also reduce the single-source shortest paths (SSSP) problem in unweighted geometric intersection graphs to decremental intersection detection. Thus, we obtain an $\OO{n \log n}$-time SSSP algorithm in unweighted intersection graphs of $n$ axis-aligned line segments.

The idemetric property: when most distances are (almost) the same.

We introduce the idemetric property, which formalizes the idea that most nodes in a graph have similar distances between them, and which turns out to be quite standard amongst small-world network models. Modulo reasonable sparsity assumptions, we are then able to show that a strong form of idemetricity is actually equivalent to a very weak expander condition (PUMP). This provides a direct way of providing short proofs that small-world network models such as the Watts-Strogatz model are strongly idemetric (for a wide range of parameters), and also provides further evidence that being idemetric is a common property. We then consider how satisfaction of the idemetric property is relevant to algorithm design. For idemetric graphs, we observe, for example, that a single breadth-first search provides a solution to the all-pairs shortest paths problem, so long as one is prepared to accept paths which are of stretch close to 2 with high probability. Since we are able to show that Kleinberg's model is idemetric, these results contrast nicely with the well known negative results of Kleinberg concerning efficient decentralized algorithms for finding short paths: for precisely the same model as Kleinberg's negative results hold, we are able to show that very efficient (and decentralized) algorithms exist if one allows for reasonable preprocessing. For deterministic distributed routing algorithms we are also able to obtain results proving that less routing information is required for idemetric graphs than in the worst case in order to achieve stretch less than 3 with high probability: while Ω(n 2) routing information is required in the worst case for stretch strictly less than 3 on almost all pairs, for idemetric graphs the total routing information required is O(nlog(n)).

Subcubic Equivalences Between Path, Matrix, and Triangle Problems

We say an algorithm on n × n matrices with integer entries in [− M , M ] (or n -node graphs with edge weights from [− M , M ]) is truly subcubic if it runs in O ( n 3 − δ ċ poly(log M )) time for some δ > 0. We define a notion of subcubic reducibility and show that many important problems on graphs and matrices solvable in O ( n 3 ) time are equivalent under subcubic reductions. Namely, the following weighted problems either all have truly subcubic algorithms, or none of them do: •The all-pairs shortest paths problem on weighted digraphs (APSP). •Detecting if a weighted graph has a triangle of negative total edge weight. •Listing up to n 2.99 negative triangles in an edge-weighted graph. •Finding a minimum weight cycle in a graph of non-negative edge weights. •The replacement paths problem on weighted digraphs. •Finding the second shortest simple path between two nodes in a weighted digraph. •Checking whether a given matrix defines a metric. •Verifying the correctness of a matrix product over the (min, +)-semiring. •Finding a maximum subarray in a given matrix. Therefore, if APSP cannot be solved in n 3−ε time for any ε > 0, then many other problems also need essentially cubic time. In fact, we show generic equivalences between matrix products over a large class of algebraic structures used in optimization, verifying a matrix product over the same structure, and corresponding triangle detection problems over the structure. These equivalences simplify prior work on subcubic algorithms for all-pairs path problems, since it now suffices to give appropriate subcubic triangle detection algorithms. Other consequences of our work are new combinatorial approaches to Boolean matrix multiplication over the (OR,AND)-semiring (abbreviated as BMM). We show that practical advances in triangle detection would imply practical BMM algorithms, among other results. Building on our techniques, we give two improved BMM algorithms: a derandomization of the combinatorial BMM algorithm of Bansal and Williams (FOCS’09), and an improved quantum algorithm for BMM.

Cache-Oblivious Buffer Heap and Cache-Efficient Computation of Shortest Paths in Graphs

We present the buffer heap , a cache-oblivious priority queue that supports Delete-Min , Delete , and a hybrid Insert / Decrease-Key operation in O (1/ B log 2 N / M ) amortized block transfers from main memory, where M and B are the (unknown) cache size and block size, respectively, and N is the number of elements in the queue. We introduce the notion of a slim data structure that captures the situation when only a limited portion of the cache, which we call a slim cache , is available to the data structure to retain data between data structural operations. We show that a buffer heap automatically adapts to such an environment and supports all operations in O (1/λ + 1/ B log 2 N /λ) amortized block transfers each when the size of the slim cache is λ. Our results provide substantial improvements over known trivial cache performance bounds for cache-oblivious priority queues with Decrease-Keys . Using the buffer heap, we present cache-oblivious implementations of Dijkstra’s algorithm for undirected and directed single-source shortest path (SSSP) problems for graphs with non-negative real edge-weights. On a graph with n vertices and m edges, our algorithm for the undirected case performs O ( n + m / B log 2 n / M ) block transfers and for the directed case performs O (( n + m / B ) ċ log 2 n / B ) block transfers. These results give the first non-trivial cache-oblivious bounds for the SSSP problem on general graphs. For the all-pairs shortest path (APSP) problem on weighted undirected graphs, we incorporate slim buffer heaps into multi-buffer-buffer-heaps and use these to improve the cache-aware cache complexity. We also present a simple cache-oblivious APSP algorithm for unweighted undirected graphs that performs O ( mn / B log M / B n / B ) block transfers. This matches the cache-aware bound and is a substantial improvement over the previous cache-oblivious bound for the problem.

Faster All-Pairs Shortest Paths via Circuit Complexity

We present a new randomized method for computing the min-plus product (a.k.a., tropical product) of two $n \times n$ matrices, yielding a faster algorithm for solving the all-pairs shortest path problem (APSP) in dense $n$-node directed graphs with arbitrary edge weights. On the real RAM, where additions and comparisons of reals are unit cost (but all other operations have typical logarithmic cost), the algorithm runs in time $\frac{n^3}{2^{\Omega(\log n)^{1/2}}}$ and is correct with high probability. On the word RAM with wordsize $\log(n)$, the algorithm runs in $n^3/2^{\Omega(\log n)^{1/2}} + n^{2+o(1)}\log(nM)$ time for edge weights in $([0,M] \cap \mathbb{Z})\cup\{\infty\}$. Prior algorithms took either $O(n^3/\log^c n)$ time for various $c \leq 2$, or $O(M^{\alpha}n^{\beta})$ time for various $\alpha > 0$ and $\beta > 2$. The new algorithm applies a tool from circuit complexity, namely the Razborov--Smolensky polynomials for approximately representing ${\sf AC}^0[p]$ circuits, to efficiently reduce a matrix product over the $(\min,+)$ algebra to a relatively small number of rectangular matrix products over $\mathbb{F}_2$, each of which is computable using a particularly efficient method due to Coppersmith. We also give a deterministic version of the algorithm running in $n^3/2^{\log^{\delta} n}$ time for some $\delta > 0$, which utilizes the Yao--Beigel--Tarui translation of ${\sf AC}^0[m]$ circuits into “nice” depth-two circuits.

Finding optimal route in the Romanian natural gas network

Abstract The Romanian natural gas market is still in its infancy regarding the manners in which the demand and supply match. We are frequently talking about market liquidity or about its dynamic behavior, without considering the monthly losses of the national natural gas system operator that derive from the very lack of matching the supply and demand. The present article proposes a method of overlaying the two in a manner that is feasible for the Romanian natural gas market of 2017, a method that will encapsulate the usage of OBAs (operational balancing agreements) in correlation with a model of allocating the demand and supply as a restricted all-pairs shortest path problem. Based on authors experience, five main variables will be examined: point-of-entry (location and time), volume, time and location of delivery, as well as other sets of data that are particular to this sector. This article will tackle the area of usability of OBAs between suppliers and the degrees of sustainability that such a model offers for clients, therefore the resilience of the system will be analyzed through an optimized transfer of information and accessibility to assets. Due to the complex nature of demand in energy markets and the different requirements set by clients, in which an energy resource can be requested by different sets of users, we will conceive a model that can be applied for natural gas, but also for electric energy production and industrial clients. The scope of this endeavor is to create a tool that will minimize the monthly losses of the national natural gas system operator, as well as its distributors, by allocating, in a fair and unbiased way, the responsibility of fulfilling the requested demand in a certain time unit.

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 the erroneous behavior of the Shoshan-Zwick algorithm and revises the algorithm to resolve the issues that cause this behavior. Moreover, it discusses implementation aspects of the Shoshan-Zwick algorithm using currently-existing sub-cubic matrix multiplication algorithms.

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.