Faster Algorithms for All Pairs Non-decreasing Paths Problem

TL;DR

This paper introduces faster algorithms for the All Pairs Non-decreasing Paths problem, achieving near-optimal time complexity on weighted digraphs and optimal time on undirected graphs, advancing the efficiency of path computations.

Contribution

It presents an improved algorithm with a time complexity of O(n^{2.686}) for weighted digraphs and an O(n^2) algorithm for undirected graphs, matching or surpassing previous bounds.

Findings

Achieves O(n^{2.686}) time for weighted digraphs.

Provides an O(n^2) time algorithm for undirected graphs.

Matches the best known bounds for related matrix product problems.

Abstract

In this paper, we present an improved algorithm for the All Pairs Non-decreasing Paths (APNP) problem on weighted simple digraphs, which has running time $\tilde{O}(n^{\frac{3 + \omega}{2}}) = \tilde{O}(n^{2.686})$. Here $n$ is the number of vertices, and $\omega < 2.373$ is the exponent of time complexity of fast matrix multiplication [Williams 2012, Le Gall 2014]. This matches the current best upper bound for $(\max, \min)$-matrix product [Duan, Pettie 2009] which is reducible to APNP. Thus, further improvement for APNP will imply a faster algorithm for $(\max, \min)$-matrix product. The previous best upper bound for APNP on weighted digraphs was $\tilde{O}(n^{\frac{1}{2}(3 + \frac{3 - \omega}{\omega + 1} + \omega)}) = \tilde{O}(n^{2.78})$ [Duan, Gu, Zhang 2018]. We also show an $\tilde{O}(n^2)$ time algorithm for APNP in undirected graphs which also reaches optimal within logarithmic factors.

Figures

Tables

Table 1. Table 1: Balancing the indegrees of vertices k 𝑘 k

Balancing the indegrees of vertices
(S1) For every $k$, sort all the in-coming edges of $k$ in increasing order and obtain the sorted list $L_k$.
(S2) Split $k$ into vertices $k_1^{\prime },k_2^{\prime },\cdots k_p^{\prime }$, and divide $L_k$ into segments each of size $n^{1-t}$ (while the last segment is possibly incomplete). The edges in the $r$-th segment is assigned to vertex $k_r^{\prime }$. Namely, edge $(j,k)$ in the $r$-th segment now becomes edge $(j,k_r^{\prime })$.
(S3) Let $[L\left(k_r^{\prime }\right),R\left(k_r^{\prime }\right)]$ denote the weight range of in-coming edges of $k_r^{\prime }$. Namely $L\left(k_r^{\prime }\right)$ is the minimum weight of in-coming edges of $k_r^{\prime }$, and $R\left(k_r^{\prime }\right)$ is the maximum. Obviously, .

Equations

$$A_{i,j}=\{\begin{array}{ll}1& \text{d(i,j)∈P}\\ 0& \text{otherwise}\end{array}$$

$$C_{i,k_r^{\prime }}\{\begin{array}{ll}>0& \text{if there is a nondecreasing path from i to kr′}\\ =0& \text{otherwise}\end{array}$$

$$A_{i,k}=\{\begin{array}{ll}1& \text{d(i,k)∈P∪Q }\\ 0& \text{otherwise}\end{array}$$

$$M\left(n,n,\frac{2^{b-l}}{n^{1-t}}\right)=O\left(\frac{n^2\cdot \frac{2^{b-l}}{n^{1-t}}}{n^{3-\omega }}\right)=O\left(n^{t+\omega }\cdot 2^{-l}\right)$$

$$M\left(n,\frac{2^{b-l}}{n^{1-t}},\frac{2^{b-l}}{n^{1-t}}\right)$$

$$=O\left(n^{(t+1)(\omega -1)+1}\cdot 2^{-l(\omega -1)}\right)$$

$$\tilde{O}\left(n^{(t+1)(\omega -1)+1-t(\omega -2)}\right)=\tilde{O}\left(n^{t+\omega }\right)$$

Full text

1 Introduction

Given a directed or undirected graph $G=(V,E)$ with arbitrary real edge weights, a non-decreasing path is a path on which edge weights form a non-decreasing sequence [9]. We define the weight of a non-decreasing path to be the weight of its last edge, which we want to minimize. The motivation of this definition comes from train scheduling [11]. Suppose each train station is mapped to a vertex of a directed graph, and a train from station $v_{1}$ to station $v_{2}$ scheduled at time $w$ is mapped to a directed edge $(v_{1},v_{2})$ with weight $w$. If we neglect the time trains spent on their way, a trip from $s$ to $t$ is just a non-decreasing path from $s$ to $t$ in the constructed graph, and the earliest time arriving at $t$ equals the minimum weight of such non-decreasing path. If we consider the train starts from $v_{1}$ at time $w_{1}$ and arrives at $v_{2}$ at time $w_{2}$, we can add a vertex $u$ and two edges $(v_{1},u),(u,v_{2})$, then gives edge weights $w_{1},w_{2}$ on them, respectively.

The Single Source Non-decreasing Paths (SSNP) problem, first studied by Minty [9] in 1958, is to find the minimum weight non-decreasing path from a given source $s$ to all $t\in V$. The first linear time algorithm for SSNP problem in RAM model was given by Vassilevska Williams [11]. She also gave an $O(m\log\log n)$ time algorithm in the standard addition-comparison model. ($m$ is the number of edges.)

The All Pairs Non-decreasing Paths (APNP) problem is the all-pairs version of the above problem, asking for the minimum weight non-decreasing path between all pairs of vertices in the graph. Vassilevska Williams [11] gave the first truly sub-cubic time algorithm of APNP. The original time complexity of the algorithm was $\tilde{O}(n^{(15+\omega)/6})$, obtained by using an $\tilde{O}(n^{2+\omega/3})$-time $(\min,\leq)$-matrix product algorithm [10] as a subroutine. Here $\omega<2.373$ is the exponent of time complexity of fast matrix multiplication [1, 12, 7], and the $(\min,\leq)$-product of two matrices $A,B$ is defined as $C_{i,j}=\min_{k}\{B_{k,j}:A_{i,k}\leq B_{k,j}\}$. It can be improved to $\tilde{O}(n^{(9+\omega)/4})$ time by using a faster $(\min,\leq)$-matrix product algorithm in $\tilde{O}(n^{(3+\omega)/2})$ time implied in [5]. Recently, Duan et al. [4] obtained a faster algorithm for APNP in $\tilde{O}(n^{\frac{1}{2}(3+\frac{3-\omega}{\omega+1}+\omega)})=\tilde{O}(n^{2.78})$, by using a simple balancing technique introduced in [5]. We also adapt this technique in our algorithm.

Computing APNP is at least as hard as the All Pair Bottleneck Paths (APBP) problem [11], which asks for the maximum bottleneck path between every pair of vertices, where the bottleneck of a path is defined as the minimum weight (capacity) among all edges on this path. The current fastest algorithm for APBP runs in $\tilde{O}(n^{(3+\omega)/2})=\tilde{O}(n^{2.686})$ time [5]. Our algorithm for APNP matches this running time, so any further improvement on APNP will imply a faster algorithm for APBP as well.

The vertex-weighted APNP problem on directed graphs, a restricted version of APNP, is computationally equivalent to the problem of Maximum Witness for Boolean Matrix Multiplication (MWBMM) [11]. An algorithm of $O(n^{2+\mu})$ time for MWBMM was given by Czumaj et al. [2], where $\mu$ satisfies the equation $\omega(1,\mu,1)=1+2\mu$ and $\omega(1,\mu,1)$ is the exponent of multiplying an $n\times n^{\mu}$ matrix with an $n^{\mu}\times n$ matrix. Currently, the best bounds on rectangular matrix multiplication by Le Gall and Urrutia [6] imply that $\mu<0.5286$.

1.1 Our results

In this paper we describe a faster algorithm for directed APNP problem running in $\tilde{O}(n^{(3+\omega)/2})$ time, which reaches optimal if the algorithm for APBP cannot be improved.

Theorem 1**.**

The all pairs non-decreasing paths (APNP) problem on directed simple graphs can be solved in $\tilde{O}(n^{(3+\omega)/2})$ time.

As in Dijkstra search [3] we can maintain a priority queue of current non-decreasing paths we have found, then the minimum unvisited one is the optimal paths between its endpoints. Every time we visit an optimal path, we “relax” all edges following that path. In [4] they partition the edge set into some parts by increasing order. For low-degree vertices in one part, trivially relax all of its outgoing edges, while for high-degree ones, use matrix multiplication to accelerate. Our algorithm adapt this idea, but we recursively divide the edges to $O(\log n)$ levels. In order the optimize the running time, a careful analysis of matrix multiplication is needed, and we need new ideas to use fast matrix multiplication to “predetermine” some of the useless edges from high-degree vertices.

We also give an $\tilde{O}(n^{2})$ time algorithm for undirected APNP, which reaches optimal within logarithmic factors.

Theorem 2**.**

The all pairs non-decreasing paths (APNP) problem on undirected simple graphs can be solved in $\tilde{O}(n^{2})$ time.

1.2 Organization of this paper

Section 2, 3, 4 will discuss our APNP algorithm for directed graphs. In Section 2, we introduce some terminologies used throughout this paper, and discuss how to recursively divide the edges. Then Section 3 and 4 will discuss our APNP algorithm for directed graphs in detail, where Section 3 explains the main techniques used, and Section 4 describes our whole algorithm and its analysis using procedures in Section 3 as subroutines. The algorithm for undirected graphs is included in Section 5. The graphs we considered in these sections have distinct edge weights, so generalization of our algorithm to equal edge weights is discussed in Appendix A.

2 Preliminaries

2.1 Basic definitions

APNP problem

Let $G=(V,E)$ be a directed simple graph with edge weight $w(e)$ for each edge $e\in E$. We denote $n=|V|$ and $m=|E|=O(n^{2})$.

A path is a sequence of edges $e_{1},e_{2},\dots,e_{l}$. A non-decreasing path is a path satisfying $\forall 1\leq i\leq l-1$, $w(e_{i})\leq w(e_{i+1})$, and the weight of this non-decreasing path is defined to be $w(e_{l})$, the weight of the last edge. All pairs non-decreasing paths problem asks to determine the minimum weight non-decreasing path between every pair of vertices. Let $OPT(i,j)$ denote the optimal (minimum) non-decreasing path between $i$ and $j$. In contrast, during the algorithm, we use $d(i,j)$ to denote the current minimum answer that our algorithm has found so far. For convenience, $OPT(i,j)$ and $d(i,j)$ also denote the weight of that path, and $w(j,k)$ denotes the weight of the edge $(j,k)$.

Notation for String and Subgraph

Without loss of generality111We include the proof in appendix A for completeness., we assume all edges have distinct edge weights ranged from [math] to $2^{b}-1$, where $b=\lceil\log_{2}|E|\rceil\leq 2\log_{2}n+O(1)$, so $2^{b}=O(n^{2})$. Then every edge weight $w(e)$ corresponds to a $b$-bit 0-1 string $[w(e)]$ which is its binary representation, with the rightmost bit being the lowest bit.

To distinguish between values and strings, string $s$ is writen as $[s]$. $LCP([w_{1}],[w_{2}])$ (which is also a binary string) is the longest common prefix of $[w_{1}]$ and $[w_{2}]$. For example $LCP([100],[101])=[10]$, and $LCP([000],[100])=[\ ]$(empty string). $|[w]|$ denotes the length of the string $[w]$, and $[x][y]$ denotes the concatenation of two strings $[x]$ and $[y]$. $[x]<[y]$ means that the lexicographical order of $[x]$ is smaller. For example, $[0111]<[101]<[1010]$.

We define $E_{[x]}=\{e\in E\ \mid\ [w(e)]\text{ has prefix }[x]\}$ to be the set of all edges whose weight has prefix $[x]$ (also call the edges have prefix $[x]$), and similarly the subgraph $G_{[x]}=(V,E_{[x]})$. For convenience, an edge set or a subgraph with subscript $[x]$ means all of the edges in it have prefix $[x]$.

Rectangular Matrix Multiplication

We use $M(m,n,p)$ to denote the asymptotic time complexity of multiplying an $m\times n$ matrix with an $n\times p$ matrix. We denote $M(n,n,n)=O(n^{\omega})$, where $\omega<2.373$ [1, 12, 7]. In this paper, rectangular matrix multiplications are straightforwardly reduced to square matrix multiplications. So we will only use the following fact. (Here $\min(x_{1},\cdots,x_{k})$ means the minimum one in $\{x_{1},\cdots,x_{k}\}$.)

Lemma 3**.**

$M(m,n,p)=O\left(\dfrac{mnp}{\min(m,n,p)^{3-\omega}}\right)$.

Proof.

The rectangular matrices are decomposed into $\min(m,n,p)\times\min(m,n,p)$ square matrices, then standard fast square matrix multiplication is applied. ∎

2.2 Naïve Algorithm

Let us first take a look at the naïve algorithm for APNP, a simple Dijkstra-type search [3]. Initially set $d(i,j)=w(i,j)$ for all edges $(i,j)\in E$, and $d(i,j)=+\infty$ otherwise. Each time we visit the minimum unvisited $d(i,j)$ and enumerate every out-going edge $(j,k)$ of vertex $j$. If $d(i,j)$ and $(j,k)$ form a nondecreasing path, then we update $d(i,k)\leftarrow\min(d(i,k),w(j,k))$. (See Algorithm 1.) We refer to this update step as relaxing edge $(j,k)$ w.r.t. $d(i,j)$. By the greedy nature of Dijkstra search, when we visit $d(i,j)$, $d(i,j)=OPT(i,j)$. Namely, it is optimal.

For clarity, our usages of symbols $i$, $j$, $k$ stick to the following convention: $d(i,k)$ refers to the path being updated by the concatenation of path $d(i,j)$ and edge $(j,k)$.

The naïve algorithm takes $O(n^{3})$ time when edge weights are integers from 0 to $2^{b}-1$, since a bucket heap of size $O(n^{2})$ is enough to maintain unvisited $d(i,j)$.

2.3 Classifying edges according to degrees

In order to avoid relaxing all edges when visiting $d(i,j)$, our algorithm will classify the edges based on the degrees of their two endpoints, and partition the edges whose both endpoints have high degrees into two sets by the order of their weights, then recursively deal with these two sets. We relax different types of edges by different approaches. First, we define “high-degree” and “low-degree” vertices in a subgraph.

High degree and low degree

In this paper, sometimes we use a subset of edges $E^{\prime}\subseteq E$ to denote the subgraph $G^{\prime}=(V^{\prime},E^{\prime})$ where $V^{\prime}$ is the set of vertices associated with $E^{\prime}$, namely, vertices in $E^{\prime}$ refers to vertices in $V^{\prime}$. In a subgraph $G^{\prime}=(V^{\prime},E^{\prime})$ of $G$, a vertex has high outdegree if its outdegree is larger than $n^{1-t}$, and otherwise, it has low outdegree. Here $t$ is a parameter to be determined later (we will choose $t=\frac{3-\omega}{2}$). Similarly, a vertex has high indegree if its indegree is larger than $n^{1-t}$, and otherwise, it has low indegree. In our algorithm, edges $(j,k)$ in a subgraph are divided into three types based on the outdegree of $j$ and indegree of $k$:

• •

Low edge: if $j$ has low outdegree

• •

High-high edge: if $j$ has high outdegree and $k$ has high indegree

• •

High-low edge: if $j$ has high outdegree and $k$ has low indegree

Divide the edges

In this binary partition procedure, starting from the entire edge set $E^{\prime}_{[\ ]}=E$, each time we divide the set of high-high edges $H_{[x]}$ in $E^{\prime}_{[x]}$ into two parts: $H^{\prime}_{[x][0]}$ and $H^{\prime}_{[x][1]}$, based on its next bit after prefix $[x]$, then recursively partition the edge sets $H^{\prime}_{[x][0]}$ and $H^{\prime}_{[x][1]}$. Here we use $L_{[x]}$ and $\Gamma_{[x]}$ to denote the low edges and high-low edges with prefix $[x]$ obtained in the algorithm.

At the beginning we call $\textsc{Divide}(E)$. Since only the edges in $H_{[x]}$ go into the next recursion, every edge can only appear in one of $\{L_{[x]}\}$ or $\{\Gamma_{[x]}\}$ but can appear in many of $\{H_{[x]}\}$.

2.4 Outline of our algorithm

In our algorithm, we run a Dijkstra-type procedure. When visiting $d(i,j)$, which is guaranteed to be optimal, we relax all the edges $(j,k)$ in $L_{[x]}$ and $\Gamma_{[x]}$ w.r.t. $d(i,j)$ for all $[x]$ which is a prefix of $[d(i,j)]$. The outdegree of $j$ is small in $L_{[x]}$ but not in $\Gamma_{[x]}$, so to relax $L_{[x]}$, we relax all edges from $j$ as the naïve algorithm. But to relax $\Gamma_{[x]}$, a preprocessing procedure of the edges in $\Gamma_{[x]}$ is needed in order to save time. For edges in $H_{[x]}$, instead of immediately relaxing them, we wait until all optimal paths with prefix $[x][0]$ are visited, then perform a $(\min,\leq)$-matrix product of these paths with the adjacency matrix of $H^{\prime}_{[x][1]}$ to relax all edges in it, so all high-high edges are relaxed w.r.t. the paths whose the longest common prefix with the edges is $[x]$. Details of these methods will be given in Section 3.

3 Basic techniques

In this section, we explain the method we use for relaxing edges. Suppose we are trying to relax edges $(j,k)$ w.r.t. $d(i,j)$, it will be based on whether $(j,k)$ is in $L_{[x]}$, $H_{[x]}$, or $\Gamma_{[x]}$.

As explained before, $L_{[x]}$ is easiest. Since $j$ has low outdegree, like the naïve algorithm, we simply relax all of its outgoing edges, which takes $O(n^{1-t})$ time. $H_{[x]}$ and $\Gamma_{[x]}$ are handled by different methods, though they both use the “row/column balancing” technique of matrix proposed in [5]. Instead of considering it as splitting rows/columns on matrix, we describe the balancing technique as splitting vertices so that every vertex has low outdegree/indegree. In the following subsections we describe the balancing technique and how to handle $H_{[x]}$ and $\Gamma_{[x]}$.

3.1 Balancing

A graph $G=(V,E)$ contains at most $\frac{|E|}{n^{1-t}}$ vertices with high indegrees or outdegrees. If there are exactly $\Theta(\frac{|E|}{n^{1-t}})$ number of vertices with high degrees, we would expect an average degree of $O(n^{1-t})$. However, there may be less vertices with high degrees, and the degrees of some vertices may be far greater than $n^{1-t}$. To balance the indegree (outdegree) of each vertex, we split every vertex into several vertices each of indegree (outdegree) $n^{1-t}$ and one vertex of indegree (outdegree) $\leq n^{1-t}$ . The number of new vertices with indegree (outdegree) exactly $n^{1-t}$ is bounded by $O\left(\frac{|E|}{n^{1-t}}\right)$, and every original high indegree (outdegree) vertex corresponds to at most one new vertex with indegree (outdegree) $<n^{1-t}$, thus we have at most $O\left(\frac{|E|}{n^{1-t}}\right)$ many new vertices each with indegree (outdegree) $\leq n^{1-t}$.

In our algorithm, for edge set $\{(j,k)\}$, we use this technique to either balance the outdegrees of vertices $j$ or the indegrees of vertices $k$. Here we demonstrate this technique for balancing indegrees of $k$ as an example in Table 1. Denote the set of edges after balancing to be $\bar{E}$, then the graph corresponding to $\bar{E}$ is actually a bipartite graph with edges between vertices $j$ and $k^{\prime}_{r}$. The procedure for balancing outdegrees of $j$ is symmetric.

3.2 High-high edges

The technique for high-high edges solves the following problem: Given a set $P$ of optimal paths of prefix $[x][0]$ and a set $H^{\prime}_{[x][1]}$ of high-high edges, the problem asks to relax all edges in $H^{\prime}_{[x][1]}$ w.r.t. paths in $P$, namely, extend paths in $P$ by a single edge in $H^{\prime}_{[x][1]}$.

This problem is equivalent with a length-two nondecreasing path problem. As discussed in Section 1, this can be solved by fast $(\min,\leq)$-product implied in [5]. But the rectangular version is not covered by [5], so we fully describe the algorithm and its analysis (in graphs).

We have two extra guarantees when we use this procedure in our main algorithm:

• •

$P$ is the set of optimal paths $OPT(i,j)$ such that $[OPT(i,j)]$ has prefix $[x][0]$, so any path $d(i,j)$ in $P$ can form a nondecreasing path with any edge $(j,k)$ in $H^{\prime}_{[x][1]}$.

• •

All $d(i,j)$ satisfying $[d(i,j)]<[x][1]$ are already visited by Dijkstra search. So we can tell whether $[OPT(i,j)]<[x][1]$ or not.

Suppose there are $n_{[x][1]}$ many $[OPT(i,j)]$ which have $[x][1]$ as a prefix. In our algorithm the time complexity will depend on $n_{[x][1]}$.

The first step is to apply the balancing technique in Section 3.1 to indegrees of vertices $k$ in $H^{\prime}_{[x][1]}$, and let the edge set after balancing be $\bar{H^{\prime}}_{[x][1]}$. Here each high indegree vertex $k$ is split into vertices $\{k^{\prime}_{r}\}$. We define the following two matrices: ($j$ and $k^{\prime}_{r}$ only include vertices having out-going edges and in-coming edges in $\bar{H^{\prime}}_{[x][1]}$, respectively.)

[TABLE]

Then we multiply them with rectangular matrix multiplication. Let $C=AB$, then,

[TABLE]

For every pair $(i,k)$ such that $[OPT(i,k)]\geq[x][1]$ ($d(i,j)\not\in P$) and $k$ is an in-coming vertex in $H^{\prime}_{[}x][1]$, we find the minimum $r$ with $C_{i,k^{\prime}_{r}}>0$ and relax all $n^{1-t}$ incoming edges $(j,k^{\prime}_{r})$ of $k^{\prime}_{r}$ w.r.t. $d(i,j)$ if $d(i,j)\in P$. We can skip other $r^{\prime}>r$ because $OPT(i,k)\leq R(k^{\prime}_{r})<L(k^{\prime}_{r^{\prime}})$. Namely, we only have to relax $O(n^{1-t})$ many edges for each $(i,k)$, which is the benefit of balancing. We attribute this $O(n^{1-t})$ cost of relaxations to the $OPT(i,k)$ with prefix $[x][1]$ found in these relaxations, which must exist if $C_{i,k^{\prime}_{r}}>0$.

The procedure above consists of three parts: finding minimum $r$ for each $(i,k)$, relaxation and matrix multiplication. The time cost for the first part is at most enumerating all nonzero elements of $C$, so it is dominated by the matrix multiplication part.

Lemma 4**.**

The relaxation part takes $O\left(n_{[x][1]}n^{1-t}\right)$ time in total.

Proof.

The cost of relaxation is attributed to each $OPT(i,k)$ with prefix $[x][1]$. Since there are $n_{[x][1]}$ many $OPT(i,k)$ with prefix $[x][1]$, and each corresponds to $O(n^{1-t})$ relaxations, it costs $O(n_{[x][1]}n^{1-t})$ time in total. ∎

Lemma 5**.**

In the matrix multiplication part, $A$ is an $n\times O\left(\min\left(n,\frac{2^{b-|[x]|}}{n^{1-t}}\right)\right)$ matrix, and $B$ is a $O\left(\min\left(n,\frac{2^{b-|[x]|}}{n^{1-t}}\right)\right)\times O\left(\frac{2^{b-|[x]|}}{n^{1-t}}\right)$ matrix, so the time complexity for matrix multiplication is $M\left(n,\min\left(n,\frac{2^{b-|[x]|}}{n^{1-t}}\right),\frac{2^{b-|[x]|}}{n^{1-t}}\right)$.

Proof.

There are at most $\min\left(n,\frac{|H^{\prime}_{[x][1]}|}{n^{1-t}}\right)$ many $j$ because vertices $j$ have high outdegrees. After balancing, there are at most $O\left(\frac{|H^{\prime}_{[x][1]}|}{n^{1-t}}\right)$ many $k^{\prime}_{r}$ by discussion in Section 3.1. Since each edge in $H^{\prime}_{[x][1]}$ has prefix $[x][1]$, $|H^{\prime}_{[x][1]}|\leq 2^{b-|[x]|-1}=O\left(2^{b-|[x]|}\right)$. Plug in the size of $H^{\prime}_{[x][1]}$ gives the desired bound. ∎

3.3 High-low edges

Now we consider the relaxation of the high-low edges in $\Gamma_{[x]}$ when visiting paths with the same prefix $[x]$. To preprocess high-low edges, we run an initialization step when all optimal paths less than $[x]$ have been visited. As before, we denote the number of $[OPT(i,j)]$ with prefix $[x]$ by $n_{[x]}$.

Since the outdegrees of vertices $j$ are high, we cannot relax edges one by one. But we still want to utilize the property that the indegrees of $k$ are low. As in the last subsection, we denote the set of optimal paths we have found to be $P$, namely when we visit $d(i,j)$, we add $d(i,j)$ to $P$. By the nature of Dijkstra search, such $d(i,j)$ is always visited in increasing order. At the initialization step, $P$ is the set of all optimal paths less than $[x]$. During the procedure, optimal paths with prefix $[x]$ are added to $P$.

We also maintain a dynamic set $Q$ which is initially empty. When we relax an edge $(j,k)$ w.r.t. $d(i,j)$, we put $d(i,k)$ into $Q$ only if $[d(i,k)]\geq[x]$, that is, $d(i,k)$ was not visited at initialization. So $Q$ contains new nondecreasing path but not guaranteed to be optimal.

Initialization by Matrix Multiplication

The first step is to apply the balancing technique to the outdegrees of vertices $j$ in $\Gamma_{[x]}$ such that every vertex $j$ in $\Gamma_{[x]}$ is split into a sequence of vertices $\{j^{\prime}_{r}\}$. Suppose the edge set after balancing is $\bar{\Gamma}_{[x]}$. Then, we define the following two matrices: ($j^{\prime}_{r}$ and $k$ only include vertices having out-going edges and in-coming edges in $\bar{\Gamma}_{[x]}$, respectively.)

[TABLE]

We compute $C=AB$. Basically speaking, the matrix $C$ can indicate whether we need to relax edges $(j^{\prime}_{r},k)$ from $j^{\prime}_{r}$ when visiting $d(i,j)$. Note that when we run initialization, $Q$ is empty, so $d(i,k)\not\in Q$ is trivially true. But we will add paths to $Q$ and dynamically update the matrix multiplication later.

We make the following observation about $C_{i,j^{\prime}_{r}}$.

Observation 6**.**

*If $d(i,j)<L(j^{\prime}_{r})$ and $C_{i,j^{\prime}_{r}}>0$, there is at least one edge $(j^{\prime}_{r},k)$ such that $d(i,k)\not\in P\cup Q$ and $[x]$ is a prefix of $[OPT(i,k)]$.

Conversely, if $C_{i,j^{\prime}_{r}}=0$, there is no such an edge $(j^{\prime}_{r},k)$.*

Proof.

Since $C_{i,j^{\prime}_{r}}>0$, at least one vertex $k$ satisfy the following:

• •

$A_{i,k}>0$ : $d(i,k)\not\in P$, so $[OPT(i,k)]\geq[x][0\cdots 0]$. Also $d(i,k)\not\in Q$.

• •

$B_{k,j^{\prime}_{r}}>0$ : $(j^{\prime}_{r},k)\in\bar{\Gamma}_{[x]}$.

Since $d(i,j)<L(j^{\prime}_{r})$, $d(i,j)$ and the original edge of $(j^{\prime}_{r},k)$ form a non-decreasing path. So $[OPT(i,k)]\leq[x][1\cdots 1]$.

Conversely, if $C_{i,j^{\prime}_{r}}=0$, for every $k$, at least one of these happens:

• •

$A_{i,k}=0$ : $d(i,k)\in P\cup Q$

• •

$B_{k,j^{\prime}_{r}}=0$ : edge $(j^{\prime}_{r},k)$ does not exist in $\bar{\Gamma}_{[x]}$.

∎

Update matrix multiplication

When a new path $d(i,k)$ is added to $P$ or $Q$, the matrix $A$ and product $C$ need to be updated. Adding a new path to $P$ or $Q$ only changes one entry of $A_{i,k}$, so we utilize the low indegree of $k$. There are at most $O(n^{1-t})$ many $j^{\prime}_{r}$ such that $B_{k,j^{\prime}_{r}}\not=0$, since $\Gamma_{[x]}$ contains high-low edges only. So the update of $C$ when changing one element $A_{i,k}$ takes only $O(n^{1-t})$ time by enumerating all nonzero $B_{k,j^{\prime}_{r}}$. This cost can be attributed to each $[OPT(i,k)]$ with prefix $[x]$, since every such path can only be added to $P\cup Q$ once. However, adding $d(i,k)$ to $Q$ does not mean we have found the optimal path $OPT(i,k)$, as it can still be updated. How to deal with this will be discussed later.

Relaxation when visiting $d(i,j)$

When we visit $d(i,j)$, for each split vertex $j^{\prime}_{r}$ of $j$, there are three cases:

$d(i,j)>R(j^{\prime}_{r})$ : $d(i,j)$ cannot form a non-decreasing path with any out-going edge of $j^{\prime}_{r}$, so we skip $j^{\prime}_{r}$. 2. 2.

$d(i,j)\in[L(j^{\prime}_{r}),R(j^{\prime}_{r})]$ : We relax all out-going edges of $j^{\prime}_{r}$ larger than $d(i,j)$. 3. 3.

$d(i,j)<L(j^{\prime}_{r})$ : Only when $C_{i,j^{\prime}_{r}}>0$, we relax all out-going edges of $j^{\prime}_{r}$ one by one.

By Observation 6, when $C_{i,j^{\prime}_{r}}=0$, for each edge $(j^{\prime}_{r},k)$, either $d(i,k)\in P$ or $d(i,k)\in Q$. If $d(i,k)\in P$, it needs no more update. If $d(i,k)\in Q$, roughly speaking, since $k$ has indegree less than $n^{1-t}$, the updates for $d(i,k)$ can be done “in advance” when it is added to $Q$. The details will be clear later. This is why we can skip $j^{\prime}_{r}$ when $C_{i,j^{\prime}_{r}}=0$.

Since the degree of $j^{\prime}_{r}$ is bounded by $n^{1-t}$, the relaxation takes $O(n^{1-t})$ time for each $j^{\prime}_{r}$. For the second case, it only happens once for each $d(i,j)$ because $[L(j^{\prime}_{r}),R(j^{\prime}_{r})]$ are disjoint for different $j^{\prime}_{r}$, so the $O(n^{1-t})$ cost is attributed to $d(i,j)$. For the third case, by Observation 6, there is at least one edge $(j^{\prime}_{r},k)$ such that $OPT(i,k)\not\in P\cup Q$ with prefix $[x]$, so the $O(n^{1-t})$ time is attributed to $d(i,k)$. (If there is more than one such $k$, choose an arbitrary one.) Then $d(i,k)$ is added to $Q$, and the cost of updating $A$ and $C$ is also bounded by $n^{1-t}$, dominated by the cost of relaxation.

Because the first path $d(i,k)$ we found for each $(i,k)$ is not necessarily the optimal one, we discuss how to handle all future updates of $d(i,k)$ “in advance” after adding it to $Q$. We enumerate every in-coming edge $(j^{\prime\prime},k)\in\Gamma_{[x]}$ of $k$. If $d(i,j^{\prime\prime})$ is not in $P$, we add $(i,k)$ to a waiting list for $(i,j^{\prime\prime})$, denoted by $W(i,j^{\prime\prime})$. When $d(i,j)$ is visited in the future, we can go through its waiting list $W(i,j)$ and update $d(i,k)$ for all pair $(i,k)$ in the list. There are only $n^{1-t}$ in-coming edges for $k$, so the waiting list construction cost is also $O(n^{1-t})$ for every $d(i,k)$.

In conclusion, we follow the procedure in Algorithm 3 when visiting $d(i,j)$ with prefix $[x]$.

Complexity

This procedure is divided into matrix multiplication part (initialization) and relaxation part (Algorithm 3) as well.

Lemma 7**.**

The relaxation part takes $O\left(n_{[x]}n^{1-t}\right)$ time.

Proof.

From discussion above, the $O(n^{1-t})$ cost of each relaxation is either attributed to optimal $d(i,j)$ with prefix $[x]$ or $d(i,k)\in Q$. For each $d(i,k)\in Q$, $OPT(i,k)$ is of course larger than $[x][0\cdots 0]$, and then relaxed by an edge $\leq[x][1\cdots 1]$, so the size of $Q$ is also bounded by $n_{[x]}$. Since each $d(i,j)$ can only be added to $P$ and $Q$ once, respectively, the total time is $O\left(n_{[x]}n^{1-t}\right)$.

The total size of all waiting lists $W(i,j)$ is bounded by $O\left(n_{[x]}n^{1-t}\right)$ as well, because each time when an $d(i,k)$ is added to $Q$, we enumerate $\leq n^{1-t}$ many incoming edges of $k$, and add $(i,k)$ to waiting list at Line 10. Every waiting list can only be relaxed once, thus, the relaxation of waiting list edges in Line 3 needs $O\left(n_{[x]}n^{1-t}\right)$ in total. ∎

The following lemma is crucial. Although edges $(j,k)$ in $\Gamma_{[x]}$ are high-low edges, the number of $k$ is not directly bounded, but remind that in our binary partition of edges, only high-high edges of previous level can be in this set, thus in fact the number of $k$ cannot be asymptotically larger than the number of $j^{\prime}_{r}$.

Lemma 8**.**

In the matrix multiplication part, $A$ is an $n\times O\left(\min\left(n,\frac{2^{b-|[x]|}}{n^{1-t}}\right)\right)$ matrix, and $B$ is an $O\left(\min\left(n,\frac{2^{b-|[x]|}}{n^{1-t}}\right)\right)\times O\left(\frac{2^{b-|[x]|}}{n^{1-t}}\right)$ matrix, so the time complexity of matrix multiplication is $M\left(n,\min\left(n,\frac{2^{b-|[x]|}}{n^{1-t}}\right),\frac{2^{b-|[x]|}}{n^{1-t}}\right)$.

Proof.

Since $|\Gamma_{[x]}|\leq 2^{b-|[x]|}$ (because each edge in it has prefix $[x]$), after balancing, there are at most $O\left(\frac{2^{b-|[x]|}}{n^{1-t}}\right)$ many $j^{\prime}_{r}$.

If $[x]\neq[]$, suppose $[x]=[x^{\prime}][0/1]$, namely $[x^{\prime}]$ is the prefix of $[x]$ which is one bit shorter. If $(j,k)\in\Gamma_{[x]}$, by Algorithm 2, $(j,k)\in H_{[x^{\prime}]}$. Since $k$ has high indegree in $H_{[x^{\prime}]}$, the number of such $k$ is bounded by $O\left(\min\left(n,\frac{|H_{[x^{\prime}]}|}{n^{1-t}}\right)\right)$. Also $|H_{[x^{\prime}]}|=O\left(2^{b-|[x]|}\right)$. Plug it in gives the $O\left(\min\left(n,\frac{2^{b-|[x]|}}{n^{1-t}}\right)\right)$ bound for the number of $k$. If $[x]=[]$, of course the number of $k$ is bounded by $n$. ∎

4 Main algorithm for directed graphs and analysis

4.1 Main algorithm

Just like in the naïve algorithm, we use a bucket to maintain all $d(i,j)$ we have found, and the minimal unvisited $d(i,j)$ is guaranteed to be optimal. Our algorithm enumerates the value $x$ from [math] to $2^{b}-1$ and visit $d(i,j)$ if $d(i,j)=x$. We carefully combine techniques introduced in the previous section into this framework.

Recall that in Algorithm 2 of Section 2.3 we define $L_{[x]}$ to be the set of low edges (from low outdegree vertices) and $\Gamma_{[x]}$ to be the set of high-low edges in $H^{\prime}_{[x]}$, which are high-high edges in higher level, then divide the edge set $H_{[x]}$ of high-high edges in $H^{\prime}_{[x]}$ to $H^{\prime}_{[x][0]}$ and $H^{\prime}_{[x][1]}$ and recursively deal with them. Our main algorithm is presented in Algorithm 4.

When visiting an optimal path $d(i,j)$, we need to relax all edges $(j,k)$ which are larger than $d(i,j)$.

Observation 9**.**

For $[d(i,j)]=[x]$, every edge $(j,k)$ larger than $d(i,j)$ must be one of the following three cases: (so $[y]$ is a prefix of both $[x]$ and $[w(j,k)]$.)

• •

$(j,k)\in L_{[y]}$* for some prefix $[y]$ of $[x]$*

• •

$(j,k)\in\Gamma_{[y]}$* for some prefix $[y]$ of $[x]$*

• •

$(j,k)\in H^{\prime}_{[y][1]}$* where $[y][0]$ is a prefix of $[x]$*

Proof.

Consider the longest common prefix $[y]=LCP([x],[w(j,k)])$. If $(j,k)$ is not in the $L_{[y^{\prime}]}$ or $\Gamma_{[y^{\prime}]}$ for any prefix $[y^{\prime}]$ of $[y]$, it must be in $H_{[y]}$. Since $[y]$ is the longest common prefix and $w(j,k)$ is larger than $d(i,j)$, $[d(i,j)]$ has prefix $[y][0]$ and $[w(j,k)]$ has prefix $[y][1]$, thus $(j,k)$ is in $H^{\prime}_{[y][1]}$. ∎

Thus, we can simply relax the edges of the first type, and use the method in Section 3.2 to relax the edges in $H^{\prime}_{[y][1]}$ when all of the optimal paths with prefix $[y][0]$ have been visited. The method for high-low edges $\Gamma_{[y]}$ is like a dynamic data structure: we initialize it when $[x]=[y][0\cdots 0]$, and update it when relaxing an edge in $\Gamma_{[y]}$.

High-high edges

For high-high edges, when $[x]=[y][100\cdots 0]$, before those $d(i,j)=x$ are visited, we append edges in $H^{\prime}_{[y][1]}$ to paths in $P_{[y][0]}=\{d(i,j)\mid[y][0]\text{ is a prefix of }[d(i,j)]\}$ using the technique introduced in Section 3.2. See Line 8, Algorithm 4.

In Section 3.2, we have two guarantees. Now we check them one by one:

• •

Because each edge in $H^{\prime}_{[y][1]}$ has prefix $[y][1]$, and each path in $P_{[y][0]}$ has prefix $[y][0]$, the maximum weight in $P_{[y][0]}$ is smaller than the minimum weight of $H^{\prime}_{[y][1]}$. At the time of $[x]=[y][100\cdots 0]$, all paths in $P_{[y][0]}$ are optimal.

• •

Since $[x]=[y][100\cdots 0]$, all $[d(i,j)]<[y][1]$ are visited, and none of $[d(i,j)]\geq[y][1]$ are visited yet.

High-low edges

We initialize for $\Gamma_{[y]}$ when $[x]=[y][000\cdots 0]$ before we visit those $d(i,j)=x$. See Line 5 of Algorithm 4. All $[d(i,j)]<[y]$ are visited, and none of $[d(i,j)]\geq[y]$ are visited. Once a $d(i,j)$ within the range $[y][000\cdots 0]\sim[y][111\cdots 1]$ is visited, we use the approach in Algorithm 3.

4.2 Correctness

We now prove the correctness of our algorithm. Suppose the last edge of $OPT(i,k)$ is $(j,k)$. Then $d(i,k)$ is correctly computed before it is visited if and only if the following two conditions holds:

• •

If $i\neq j$, $d(i,j)$ is correctly computed before it is visited.

• •

After $d(i,j)$ is visited, before we visit $d(i,k)$, $d(i,k)$ is updated by relaxing the edge $(j,k)$ w.r.t. $d(i,j)$.

We prove the second condition holds for every $d(i,j)$, and the first one simply follows from induction.

Suppose $[z]=LCP([OPT(i,j)],[OPT(i,k)])=LCP([OPT(i,j)],[w(j,k)])$. By Observation 9 the last edge $(j,k)$ must be in one of the three cases, so we check them one by one.

Lemma 10**.**

If $(j,k)$ is in $L_{[y]}$ for some prefix $[y]$ of $[z]$, and $d(i,j)$ is correctly computed before visited, then $d(i,k)$ is also correctly computed before visited.

Proof.

Because $[y]$ is also a prefix of $[OPT(i,j)]$, at Line 12, when we visit $d(i,j)$, $d(i,k)$ is updated by relaxing $(j,k)$. Because $OPT(i,j)<OPT(i,k)$, $d(i,k)$ is not visited yet. ∎

Lemma 11**.**

Suppose $(j,k)$ is in $H^{\prime}_{[y][1]}$ where $[y][0]$ is a prefix of $[OPT(i,j)]$. If $d(i,j)$ is correctly computed before visited, $d(i,k)$ is also correctly computed before visited.

Proof.

We can see $[y]=[z]$ from the proof of Observation 9. At Line 8, when $[x]=[y][100\cdots 0]$, $d(i,k)$ is updated by $d(i,j)$ and $(j,k)$. $d(i,j)$ is already visited before because it has prefix $[y][0]$. $d(i,k)$ will be visited later because it has prefix $[y][1]$. ∎

Lemma 12**.**

If $(j,k)$ is in $\Gamma_{[y]}$ for some prefix $[y]$ of $[z]$, and $d(i,j)$ is correctly computed before visited, then $d(i,k)$ is also correctly computed before visited.

Proof.

Since $[y]$ is a prefix of both $[OPT(i,j)]$ and $[w(j,k)]$, the initialization for $\Gamma_{[y]}$ is done at Line 5 when $[x]=[y][000\cdots 0]$. After that, $d(i,k)$ is updated when we visit $d(i,j)$ at Line 13. $d(i,k)$ is not visited yet because $OPT(i,k)>OPT(i,j)$. ∎

Lemma 13**.**

All $d(i,j)$ are correctly computed before visited.

Proof.

This follows from a simple induction. In the base case, for all length $1$ optimal paths $OPT(i,j)$, they are obviously correctly computed in Line 1. Then if all length $l-1$ paths $OPT(i,j)$ are correctly computed before visited, by Lemma 10, 11, 12, all length $l$ paths $OPT(i,j)$ are also correctly computed before visited. ∎

4.3 Running time

Lemma 14**.**

The relaxation for low edges ($L_{[x]}$) takes $\tilde{O}\left(n^{3-t}\right)$ time in total. (Line 12)

Proof.

At Line 12, we only enumerate $O(n^{1-t})$ many edges because $j$ has low outdegree in $L_{[y]}$. Since there are only $b=O(\log n)$ many prefix $[y]$ for each $[d(i,j)]$, each $d(i,j)$ takes $\tilde{O}(n^{1-t})$ time. So in total, these updates take $\tilde{O}(n^{3-t})$ time for all $O(n^{2})$ many $d(i,j)$. ∎

Lemma 15**.**

The relaxation for high-high edges and high-low edges besides matrix multiplication takes $\tilde{O}\left(n^{3-t}\right)$ time in total.

Proof.

By Lemma 4 and Lemma 7, for each $[y]$, the complexity for relaxation is bounded by $(n_{[y]}+n_{[y][1]})n^{1-t}=O\left(n_{[y]}n^{1-t}\right)$, where $n_{[y]}$ stands for the number of optimal paths with prefix $[y]$. Since an optimal path can be counted in $O(\log n)$ many $n_{[y]}$, the total time is therefore $\tilde{O}(n^{3-t})$. ∎

Lemma 16**.**

The matrix multiplication parts for high-high edge updates and the initialization of high-low edge updates take $\tilde{O}\left(n^{t+\omega}\right)$ time in total.

Proof.

By Lemma 5 and 8, the complexity for matrix multiplication is at most $M\left(n,\min\left(\frac{2^{b-|[y]|}}{n^{1-t}},n\right),\frac{2^{b-|[y]|}}{n^{1-t}}\right)$ for each $[y]$. We fix the length of $[y]$, denoted by $l=|[y]|$, then consider the two cases:

• •

$2^{l}<n^{t}$ : There are at most $2^{l}$ many such $[y]$, and each takes

[TABLE]

This follows from both Lemma 3 and the fact that $2^{b}=|E|=O(n^{2})$. For each $l$, the time complexity is exactly $O(n^{t+\omega})$. So the total complexity is $\tilde{O}(n^{t+\omega})$ since $l=O(\log_{2}(n))$.

• •

$2^{l}\geq n^{t}$ : There are at most $2^{l}$ many such $[y]$. Each takes

[TABLE]

So for all $[y]$ of length $l$, it takes $O\left(n^{(t+1)(\omega-1)+1}\cdot 2^{-l(\omega-2)}\right)$ time. The term $2^{-l(\omega-2)}$ is maximized when $l$ is minimized, so $2^{-l(\omega-2)}\leq n^{-t(\omega-2)}$, and the total time for all lengths of $[y]$ is

[TABLE]

∎

Theorem 17**.**

The All Pair Non-decreasing Paths (APNP) problem on directed graphs can be solved in $\tilde{O}\left(n^{\frac{3+\omega}{2}}\right)$ time. The optimal path of length $l$ between any two vertices can also be explicitly found in $O(l)$ time if we slightly modify the algorithm.

Proof.

We choose $t=\frac{3-\omega}{2}$. The running time of this algorithm follows from previous lemmas. Since all optimal paths $OPT(i,k)$ are obtained by relaxation of edges $(j,k)$, we can store the last edge $(j,k)$ for each $OPT(i,k)$, so retrieving the optimal path can be done in $O(l)$ time. ∎

5 Near-optimal algorithm for undirected APNP

In this section we show that the APNP problem on undirected graphs can be solved in time $\tilde{O}(n^{2})$. Let $G=(V,E)$ be an undirected graph with $m=O(n^{2})$ edges $e_{1},e_{2},\dots,e_{m}$. For simplicity we assume that the weights $w(e_{i})$ of edges are distinct using Lemma 23 in Appendix A. But here we allow multiple edges in $G$.

5.1 Basic algorithm

Our algorithm proceeds as follows: Beginning from an empty graph, we successively insert the edges in ascending order of weights. An $n\times n$ zero-one matrix $A$ is maintained and updated after each insertion, where $A_{i,j}=1$ if an only if there exists a non-decreasing path $(i,j)$ consisting only of edges that are already inserted. If $A_{i,j}$ is updated from 0 to 1 when inserting edge $e$, we have $OPT(i,j)=w(e)$. Algorithm 5 below is a straightforward implementation of this algorithm in time $O(n^{3})$, in which non-infinity elements of matrix $D$ denote the optimal answers.

Lemma 18**.**

When the $k$-th iteration of the for-loop at Line 6 is finished, for every pair of vertices $i,j$, $A_{i,j}=1$ if an only if there exists a non-decreasing path $(i,j)$ consisting only of edges in $E_{k}=\{e_{1},\dots,e_{k}\}$.

Proof.

For $k=0$, the for-loop has not started, and $A_{i,j}=1$ if and only if $i=j$. The lemma trivially holds since a path $(i,j)$ with edges in $E_{0}=\emptyset$ must satisfy $i=j$.

For $1\leq k\leq n$, suppose the lemma holds for $k-1$. If $A_{i,j}=1$ before the $k$-th iteration, it should still be $1$ after the $k$-th iteration since $E_{k-1}\subset E_{k}$. Our algorithm never updates $A_{i,j}$ from 1 to 0.

If $A_{s,t}=0$ before the $k$-th iteration, it should be updated to 1 in the $k$-th iteration if and only if there exists a non-decreasing path $(s,t)$ containing $e_{k}$. Since $w(e_{k})=\max_{e\in E_{k}}w(e)$, it can only appear as the last edge of a non-decreasing path. Let $e_{k}=(i,j)$. Then the two possibilities of this path are $s\to i\to j$ and $s\to j\to i$. Our algorithm checks each possible $s$ and can find all such new paths. ∎

Theorem 19**.**

Algorithm 5 correctly computes the APNP matrix $D$.

Proof.

From Lemma 18, if $A_{i,j}$ is updated from [math] to $1$ in the $k$-th iteration, there exists a non-decreasing path $(i,j)$ using edges $\{e_{1},\dots,e_{k}\}$, but it does not exist when only $\{e_{1},\dots,e_{k-1}\}$ can be used. Since $w(e_{1})<w(e_{2})<\dots<w(e_{m})$, we must have $OPT(i,j)=w(e_{k})$. ∎

5.2 Equality-tests on dynamic strings

To speed up our algorithm, it is necessary to maintain the zero-one matrix more efficiently. We will use the data structure introduced in [8], which supports useful operations on a dynamic family of zero-one strings. A zero-one string $s$ of length $n$ can be viewed as an array of elements $s_{1},s_{2},\dots,s_{n}$, where $s_{i}\in\{0,1\}$ for every $i$.

Theorem 20** ([8]).**

There is a deterministic data structure that supports the following operations on an initially empty family of zero-one strings.

• •

$\textsc{Equal}(s_{1},s_{2})$: Test if two strings $s_{1},s_{2}$ are equal.

• •

$\textsc{Makestring}(s,c)$: Create string $s$ with a single element $c\in\{0,1\}$ .

• •

$\textsc{Concatenate}(s_{1},s_{2},s_{3})$: Create a new string $s_{3}=s_{1}s_{2}$ without destroying $s_{1}$ and $s_{2}$.

• •

$\textsc{Split}(s_{1},s_{2},s_{3},i)$: Create two new strings $s_{2}=a_{1}\dots a_{i}$ and $s_{3}=a_{i+1}\dots a_{|s_{1}|}$ without destroying $s_{1}=a_{1},\dots a_{|s_{1}|}$.

Let $n$ denote the total length of all strings created. Then the $m$-th operation takes $\mathrm{poly}\log(nm)$ time.

Creating a string $s$ can be performed using $O(|s|)$ Makestring and Concatenate operations. Modifying one bit of a string can be performed using $O(1)$ Split, Makestring and Concatenate operations. Given two strings $s,t$, using standard binary search, we can find the smallest $i$ (if exists) such that $s_{i}\neq t_{i}$ using $O(\log|s|)$ Split and Equal operations.

5.3 Faster algorithm

Using this data structure, our algorithm can be implemented as in Algorithm 6. In this new algorithm, matrix $A$ is replaced by $n$ zero-one strings $B_{i}$, which are maintained by the data structure. $B_{i,j}$ is the $j$-th element in $B_{i}$. $B_{i,s}$ corresponds to $A_{s,i}$ in the previous basic algorithm, that is, $B_{i}$ corresponds to the $i$-th column of $A$. The correctness of this algorithm is obvious since it is equivalent to Algorithm 5.

Theorem 21**.**

The all pairs non-decreasing paths (APNP) problem on undirected graphs can be solved in $\tilde{O}(n^{2})$ time.

Proof.

To analyze the time complexity, note that creating the strings $\{B_{i}\}$ takes $O(n^{2})$ Makestring and Concatenate operations. The for-loop at Line 5 is executed for $m=O(n^{2})$ times. Every time the while-loop from Line 8 to Line 12 is executed, one element of either $B_{i}$ or $B_{j}$ is updated from 0 to 1. Since the total length of strings $B_{i}$ is $n^{2}$, and elements are never changed from 1 back to 0, the number of updates is $O(n^{2})$. Each execution of the comparison and the while-loop takes $\mathrm{poly}\log(n)$ time by using the data structure. (Note that comparing $B_{i}$ and $B_{j}$ and finding the first different bit take $O(\log n)$ operations by binary search.) Hence, the total time of this algorithm is $O(n^{2}\mathrm{poly}\log(n))=\tilde{O}(n^{2})$. ∎

Appendix A Handling equal weights

In this section we discuss the generalizations of our algorithm to multiple edges and equal edge weights.

Observation 22**.**

We can generalize our algorithm for directed graphs to handle multiple edges, but still with distinct edge weights. When the number of edges $m=O(n^{2})$, the running time is still $\tilde{O}\left(n^{\frac{3+\omega}{2}}\right)$

The Dijkstra search is not affected by multiple edges, so the edge relaxation of low edges and high-low edges parts still works. For high-high edges, since we relax a set of edges $H^{\prime}_{[x][1]}$ w.r.t. paths with smaller weights together, we can simply only keep the smallest edge when there are multiple edges in $H^{\prime}_{[x][1]}$ between a pair of vertices.

This observation is helpful to handle edges of equal weights:

Lemma 23**.**

Given a directed simple graph $G=(V,E)$, one can construct in $\tilde{O}(n^{2})$ time a new directed graph $H=(V,E^{\prime})$ (possibly having multiple edges) on the same vertex set $V$ with distinct edge weights, such that the APNP matrix of $G$ can be computed in $\tilde{O}(n^{2})$ time given the APNP matrix of $H$ as input. The size of the new edge set $E^{\prime}$ satisfies $|E^{\prime}|\leq 2|E|$.

For undirected graph $G$ this statement also holds, and the constructed $H$ will be undirected as well.

Proof.

For a given number $w$, let $G_{w}=(V,E_{w})$ denote the subgraph of $G$ consisting of all edges with weight exactly $w$. For all edge weight $w$, we construct in $O(|E_{w}|)$ time a new graph $H_{w}=(V,E_{w}^{\prime})$ where $|E_{w}^{\prime}|\leq 2|E_{w}|$ and all edge weights are distinct, such that: for any $s,t\in V$, $G_{w}$ contains a path from $s$ to $t$ if and only if $H_{w}$ contains a non-decreasing path (actually strictly increasing) from $s$ to $t$. Once this is shown, the proof immediately follows by merging all $H_{w}$’s into a single graph $H=(V,\,\bigcup_{w}E_{w}^{\prime})$, assuming edges from $E^{\prime}_{x}$ all have smaller weights than those from $E^{\prime}_{y}$ if $x<y$.

Now we describe our construction of $H_{w}$ in undirected and directed cases respectively.

Undirected case

For every connected component $C=\{v_{1},v_{2},\dots,v_{k}\}$ in $G_{w}$, we set $v_{1}$ as the ”assembly vertex”, and construct $2(k-1)$ undirected edges $(v_{1},v_{2}),\dots,(v_{1},v_{k})$, $(v_{k},v_{1}),\dots,(v_{2},v_{1})$ with increasing weights. So for each pair of (non-assembly) vertices $v_{i},v_{j}$ in the same component, there exists a strictly increasing path $v_{i}\rightarrow v_{1}\rightarrow v_{j}$ in between. We can treat all connected components of $G_{w}$ in arbitrary order.

Directed case

Let $V_{w}$ be the set of vertices associated with edges in $E_{w}$. We contract every strongly connected components (SCC) of $G_{w}$ into a big node, and thus obtain a directed acyclic graph (DAG) $G^{\prime}$. Suppose $G^{\prime}$ contains $n^{\prime}$ big nodes (SCCs of $G$) and $m^{\prime}$ edges between different big nodes. Our construction of $H_{w}$ consists of $2(|V_{w}|-n^{\prime})+m^{\prime}\leq 2|E_{w}|$ edges with weights in strictly increasing order, described as below.

Initially, $H_{w}$ contains no edge. We add edges one by one into $H_{w}$ in increasing order of their weights. For each strongly connected component $C=\{v_{1},\dots,v_{k}\}$ in $G_{w}$, we select (arbitrarily) vertex $v_{1}$ as an assembly vertex. The first $|V_{w}|-n^{\prime}$ edges we add are those edges from each non-assembly vertex to the assembly vertex in its component. Namely, for each component, we add $k-1$ edges $(v_{2},v_{1}),\dots,(v_{k},v_{1})$ with distinct weights.

The next $m^{\prime}$ edges we add comes from the edges in the DAG $G^{\prime}$. We sort big nodes in $G^{\prime}$ in topological order, and process each edge $(u,v)\in G^{\prime}$ by the topological order of $u$. For $(u,v)\in G^{\prime}$ from component $u$ to component $v$, we add $(u^{\prime},v^{\prime})$ to $H_{w}$, where $u^{\prime},v^{\prime}$ are the assembly vertices of SCCs $u$ and $v$, respectively.

The last $|V_{w}|-n^{\prime}$ edges we add are edges from each assembly vertex to every other vertex in its component. Namely, for each component $C=\{v_{1},\dots,v_{k}\}$, we add $k-1$ edges, $(v_{1},v_{2}),(v_{1},v_{3}),\dots,(v_{1},v_{k})$.

Then for every path $i\rightarrow j$ in $G_{w}$, there is a corresponding increasing path $i\rightarrow i^{\prime}\rightarrow j^{\prime}\rightarrow j$ in the constructed $H_{w}$, where $i^{\prime},j^{\prime}$ are the assembly vertices of the components containing $i$ and $j$, respectively. The fact that an increasing path exists between $i^{\prime}$ and $j^{\prime}$ follows from the basic property of topological order. ∎