    # Disjoint Shortest Paths with Congestion on DAGs

In the k-Disjoint Shortest Paths problem, a set of source terminal pairs of vertices {(s_i,t_i)| 1≤ i≤ k} is given and we are asked to find paths P_1,…,P_k such that each path P_i is a shortest path from s_i to t_i and every vertex of the graph routes at most one of such paths. We introduce a relaxation of the problem, namely, k-Disjonit Shortest Paths with Congestion-c where every vertex is allowed to route up to c paths. In this work we provide a simple algorithm to solve the k-Disjonit Shortest Paths with Congestion-c problem in time f(k) n^O(k-c) on DAGs. Along this way, we significantly simplify the argument that is used in the previous work for k-Disjoint Paths with Congestion-c by Amiri et al. We also discuss the hardness of problem and open problems in this area.

## Authors

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

The -Disjoint Paths Problem is one of the fundamental connectivity problems in graph theory. The input is a graph and a set of source and terminal pairs ; the question is to connect every source to by internally vertex disjoint paths. The problem plays a central role in proving the graph minor theorem algorithmically .

A relaxation of the problem allows congestion on nodes and edges of the graph. Such a generalization is relevant in practice: for instance, in communication networks we can tolerate a certain amount of congestion. Routing disjoint paths with congestion have been extensively studied in the literature e.g., see [20, 1, 16, 8, 9].

Another practical variation of the problem is to find disjoint paths that are shortest with respect to certain measures: every path is a shortest path connecting the terminal pairs, or the total length is minimized, or the maximum path length is minimized, etc., see [17, 18, 7, 11] for some of such cases.

Most of the aforementioned variations add a criteria that makes the problem more difficult than the classical disjoint paths problem. However, one variation might make the problem easier: when every path connecting a source to a terminal should also be a shortest such path. This is known as the -Disjoint Shortest Paths problem (-DSP).

Not much was known about -DSP since it had been raised as an open problem over 20 years ago . The only known results were for the restricted case of two paths for undirected graphs [14, 12] and digraphs . Only recently, two separate groups provided algorithms with running time of  [19, 5] for -DSP on undirected graphs. The problem is wide open for general digraphs, even for the special case of -DSP.

In this paper we consider a generalized version of the -DSP, namely the -Disjoint Shortest Paths with Congestion- problem. This is similar to the -DSP except that every vertex can tolerate a congestion , that is, it can route up to paths.

We study the computational complexity of the problem on directed acyclic graphs (DAGs). DAGs are valuable in simulating scheduling problems. In such simulations, finding disjoint paths, and in particular disjoint paths of short length is quite important. For a nice example of such simulations we refer the reader to the introduction of .

Besides their practical applications, DAGs are basic building blocks to study the theoretical aspects of general digraphs. Several digraph width measures are designed to measure similarity of the input graph to DAGs [15, 4, 6, 22].

It is possible to devise an algorithm for our problem on DAGs (e.g. see Lemma 3). However, we investigate the possibility of performing better when the congestion is close to . The intuition is that if the congestion is we only have to route shortest paths. Let us define , then we seek for an algorithm with running time , for some computable functions and .

In undirected graphs nothing is known about the problem. One might be able to convert the existing works on -DSP to -Disjoint Shortest Paths with Congestion- to obtain desired solution. However, there are two issues with this approach: First, the recently developed algorithms for -DSP are only relevant from a theoretical perspective since their running times are doubly and triply exponential [19, 5]. Second, a direct transformation (e.g. an extension of our Lemma 3) would result in appearing in the exponent of while we prefer to see in the exponent instead of .

We show that the problem is solvable in polynomial time on DAGs for constant values of by providing a algorithm. Our algorithm matches the running time of the best known algorithm for -Disjoint Paths with Congestion- on DAGs .

The algorithm is based on the previous work  for -Disjoint Paths with Congestion-. However, we significantly simplify the analysis of the most challenging part of the previous work while making it applicable on both variations of the problem.

We then show that it is not possible to find a significantly faster algorithm than ours, assuming Exponential Time Hypothesis (ETH) is correct. At the end existing open problems are discussed.

In this work, we assume basic familiarity with graph theory, and parameterized complexity, for both concepts we refer the reader to the book .

An instance of the problem is composed of the input graph and an integer as congestion and a subset of size of source terminal pairs . When it is clear from context, we may only refer to source terminal pairs of . In addition we may further abbreviate it and write terminal pairs. Every edge may have a positive integer as its weight (or by default); denotes the number of vertices of .

## 2 Algorithm

First, let us recall the approach of  for disjoint paths with congestion, then we introduce our intuitive analysis for disjoint shortest paths with congestion. The general idea of  was inspired by kernelization techniques: reduce the instance to smaller instances with congestion . In particular, sub-instances with at most pairs (recall that ). Since we know how to solve the -Vertex Disjoint Paths problem in time we can solve the -Disjoint Paths with Congestion- in almost the same running time.

The main challenge in the previous work was the reduction to a smaller instance. We provide such a reduction in the following lemma, which is analogous to Lemma 8 of . Our argument is simpler and intuitive, in addition directly applies to both problems. In the following everything goes the same way even if we have edge weights.

###### Lemma 1.

Let , then there is a solution to an instance of -Disjoint Shortest Paths with Congestion-  in a DAG if and only if the following two conditions hold:

• [topsep=0pt]

• there is a path in between each source terminal pair of ,

• there is a set of terminal pairs of such that -Disjoint Shortest Paths with Congestion- has a solution for the terminal pairs of .

###### Proof.

We assume the first condition is fulfilled, otherwise we are done.

If a solution to with congestion is given then we can route the rest of paths arbitrarily by their shortest paths and the congestion does not exceed .

We may assume has a vertex of congestion otherwise drop a pair from and the corresponding path from to work on a smaller instance (update ). As long as and has no vertex of congestion we repeat the above process. The following claim is our main contribution to show the reverse implication of lemma.

Claim. If has a vertex of congestion then has a solution such that:

• congestion of every vertex is the same in and and,

• there is a path that contains all vertices of congestion .

Let us first show how the lemma follows from the claim. If the claim is correct then remove the endpoints of from to obtain . Then is a solution for . Afterwards update and as long as repeat the same process. Once we have an instance with pairs, the lemma follows.

Proof of Claim. Order vertices of congestion in w.r.t. their topological order in to obtain a strictly increasing ordered set of them . If there is a path that visits all vertices of we are done; otherwise, we need the following observation from the proof of Lemma 8 in :

Observation For every (at most) vertices there is a path of that contains all of them: since , share at least common paths and since congestion of is it routes at least one of these paths.

Note that if then there is a path that contains all vertices of and we are done, hence in the rest we assume . There is a path ( connects the ’th terminal pair) that contains but not a vertex . We reroute paths of so that the updated , we call it , contains .

Choose such that (w.r.t. their order in ) and additionally they are closest such high congestion pair of vertices in surrendering ; i.e., for every other pair of vertices if then and .

By there is a path such that . Replace a subpath of that starts and ends at with a subpath of that starts and ends at resp., to obtain paths . Let define . By choice of , we have . Additionally, contains at least a new high congestion vertex . The congestion of all vertices and the path lengths in are the same as in . Thus, is a solution to . See Figure 1 for an illustration of rerouting.

We repeat the same process to construct paths ; since each has more high congestion vertices than , eventually we construct a path (for some ) in a solution that contains all vertices of congestion as claimed.∎

To find a feasible routing for a small set of terminal pairs in , the algorithm of Fortune et al.  was employed. For disjoint shortest paths, we are not aware of any such algorithm, thus we provide one. In the following our focus is the simlicity not optimality. Later in Section 3 we discuss a faster approach. The following might be known as folklore, however, our presentation is independent of any prior work.

For a directed edge (), its tail is and is its head; we write .

###### Lemma 2.

The -DSP problem on DAGs can be solved in time .

###### Proof.

We solve a more general version of -DSP problem: For every tuple of source and terminal pairs, , we solve -DSP between them. If there is a solution for , store it in a dictionary ; i.e. . otherwise set .

To solve the above problem, first topological sort vertices of the graph as . Afterward, recursively solve the problem in subsets of vertices and for every -tuple in these subsets (). Then any -tuple for the union of two sets falls in one of the following two categories ():

• can be partitioned into two tuples where and .

• There is a source terminal pair such that .

For the first case if () is not empty but there is no solution for it, i.e., , then set otherwise set .

It remains to solve the second case. Suppose terminal pairs of have one end in and the other end in , let us call the set of them .

If there is a solution for then there are paths in going along an ordered set of edges where . We do not know the endpoints of these edges but we can guess them.

Afterwards create two new sub-instances : contains all source and terminal pairs that are entirely in , in addition it has additional source terminal pairs where their source vertices are the sources in and the terminal vertices are the tail of corresponding edges (according to their order) in . Similarly has all source and terminal pairs of that are entirely in and a new set of source terminal pairs where their sources are the heads of edges in and their terminals are the terminals of . For an illustration of and the edge set  see Figure 2.

In time we can check if are non-empty and their concatenation with edges of yields a valid solution for . If it is so, we set . If no such set of edges provides a desired solution for , we set .

Since we considered all possibilities of -tuples of the terminals, at the end of the algorithm, for a given tuple of source terminal pairs, we pick its value from .

The running time of each recursive step is dominated by the merge operation, which can be done in : there are -tuples, for each of them we guess ordered sets of at most -edges, and in we compare each path length (summation of values) with the corresponding value of the shortest path matrix. Since the input set of vertices in each call is partitioned, the total number of merge steps is , hence the running time is as claimed. ∎

The following is similar to Lemma 6 of , except that we use Lemma 2 instead of algorithm of Fortune et al.

###### Lemma 3.

There is an algorithm that solves the -Disjoint Shortest Paths with Congestion- in time on DAGs.

###### Proof.

From the input graph construct a graph as follows: for every add vertices to ; if then add edges to (with the same weight as ). A solution to the -Disjoint Shortest Paths with Congestion- in is equivalent to -DSP in with terminal pairs . Since the size of is at most times bigger than , by Lemma 2 we can solve the latter in time .

Now our main theorem is a consequence of previous lemmas.

###### Theorem 4.

The -Disjoint Shortest Paths with Congestion- problem in acyclic graphs can be solved in time .

###### Proof.

If then we directly apply Lemma 3, otherwise, by Lemma 1 we only need to guess source terminal pairs (there are such choices) then route them in time using Lemma 3. Afterwards connect the remaining pairs via their shortest paths. If the algorithm fails in any phase, there is no solution to the given instance∎

## 3 After Math

We would like to discuss several topics here.

Comparison to the earlier work

Our main goal was to provide a simple algorithm for the problem. The main algorithmic contribution of both papers are their reduction steps. The one in the previous work  has a short and elegant proof, however, it is dense. Our new proof in Lemma 1 is much shorter and in addition, we elaborated on missing details of the prior work.

Our main observation is simple to explain and prove: given any solution, it is possible to transfer it to one that includes a path going through all high congestion vertices. The earlier work does not benefit from such an intuitive proof, instead, several levels of nested assumptions on parameters have been made to prove the theorem by contradiction.

The Disjoint Shortest Paths algorithm

Employing the technique of Fortune et al. (they call it pebbling game) we could improve the running time of Lemma 2: for instance, construct a similar DAG as Fortune et al., where its vertices are all possible -tuples of vertices and there is a directed edge between a pair of tuples if they meet certain criteria (to enable the transition from one to another), or in their wording, if it is a legal move. For -DSP, we have to add one more condition to their legal move to ensure the paths are shortest path.

The rest goes similar to Fortune et al.: find a path in the DAG of tuples that connects the -tuple of sources to the -tuple of terminals (if such a path exists). Such a path, by a naive approach, can be found in time .

We believe that formalizing the above idea, makes it less intuitive, therefore we presented Lemma 2 with a divide and conquer algorithm which enjoys a simple merge step.

Similarly, in our algorithm, we could have processed vertex by vertex according to their topological order to find a solution for each -tuple. With a careful analysis, this leads to a faster algorithm than the one of Lemma 2.

Hardness

The recent hardness construction of Bentert et al.  for -DSP on undirected graphs extends to DAGs. They have sets of horizontal and vertical paths; we direct them from left to right and top to bottom resp., to obtain a DAG. This keeps the length of the source terminal shortest paths as before, thus, we get the following corollary.

###### Corollary 5.

The -DSP problem has no algorithm on DAGs unless ETH fails.

For the -DSP with congestion, to provide a lower bound with dependency on , one can show that every path in the hardness reduction of 111We cited the conference version since it is public and this part is the same as the journal version., is either a shortest path or it can be replaced with a shortest path without increasing congestion of any vertex. However, for technical reasons, we have to first modify the original construction then argue that it works for the shortest path variation. We excluded that discussion from this paper since it adds non-algorithmic technical details that are beyond the original goal of this work.

## 4 Open Problems

There are several related open problems on this topic. The major open problem is to verify if the -Disjoint Shortest Paths with Congestion- problem in general graphs admits an algorithm with running time for computable functions and . However, approaching this problem might be a bit ambitious, since the complexity of the simpler problem of -Disjoint Shortest Paths is wide open in digraphs, even for a restricted case of . We believe such an algorithm does exist.

Since there are algorithms for -DSP in undirected graphs, a more accessible open problem is to solve -Disjoint Shortest Paths with Congestion- in undirected graphs in time . Another direction is to improve the running time of the existing -DSP algorithms to make them practical.

The running time of our algorithm is close to the lower-bound. We route source terminal pairs in the worst case, thus we have a barrier of in the running time (unless algorithm of Fortune et al., can be improved). Is it possible to change our reduction step so that it requires routing fewer paths? More generally is there an algorithm for DAGs with run time , for some constant ?

In the running time of our algorithm (similarly the algorithm of ), does not appear in the exponent of but an exponential function appears as a multiplicative factor. Is this exponential dependency on inevitable under reasonable computational assumptions?

Another direction is to study the problem when the underlying graph has certain structural properties. For instance, if it is planar or if it has a constant directed treewidth. Note that here we wish to see running time of form not , where denotes the directed treewidth of the graph.

## References

•  Saeed Akhoondian Amiri, Szymon Dudycz, Stefan Schmid, and Sebastian Wiederrecht. Congestion-free rerouting of flows on dags. In ICALP, volume 107 of LIPIcs, pages 143:1–143:13, 2018.
•  Saeed Akhoondian Amiri, Stephan Kreutzer, Dániel Marx, and Roman Rabinovich. Routing with congestion in acyclic digraphs. In MFCS, volume 58 of LIPIcs, pages 7:1–7:11, 2016.
•  Saeed Akhoondian Amiri, Stephan Kreutzer, Dániel Marx, and Roman Rabinovich. Routing with congestion in acyclic digraphs. Inf. Process. Lett., 151, 2019.
•  Saeed Akhoondian Amiri, Stephan Kreutzer, and Roman Rabinovich. Dag-width is pspace-complete. Theor. Comput. Sci., 655:78–89, 2016.
•  Matthias Bentert, André Nichterlein, Malte Renken, and Philipp Zschoche. Using a geometric lens to find k disjoint shortest paths. CoRR, abs/2007.12502, 2020.
•  Dietmar Berwanger, Anuj Dawar, Paul Hunter, Stephan Kreutzer, and Jan Obdrzálek. The dag-width of directed graphs. J. Comb. Theory, Ser. B, 102(4):900–923, 2012.
•  Andreas Björklund and Thore Husfeldt. Shortest two disjoint paths in polynomial time. In Automata, Languages, and Programming, pages 211–222, Berlin, Heidelberg, 2014. Springer Berlin Heidelberg.
•  Chandra Chekuri and Alina Ene. Poly-logarithmic approximation for maximum node disjoint paths with constant congestion. In SODA, pages 326–341, 2013.
•  Chandra Chekuri, Sanjeev Khanna, and F. Bruce Shepherd. Edge-disjoint paths in planar graphs with constant congestion. SIAM J. Comput., 39(1):281–301, 2009.
•  Marek Cygan, Fedor V. Fomin, Lukasz Kowalik, Daniel Lokshtanov, Dániel Marx, Marcin Pilipczuk, Michal Pilipczuk, and Saket Saurabh. Parameterized Algorithms. Springer, 2015.
•  Éric Colin de Verdière and Alexander Schrijver. Shortest vertex-disjoint two-face paths in planar graphs. ACM Trans. Algorithms, 7(2):19:1–19:12, 2011.
•  Tali Eilam-Tzoreff. The disjoint shortest paths problem. Discrete Applied Mathematics, 85(2):113 – 138, 1998.
•  Steven Fortune, John Hopcroft, and James Wyllie. The directed subgraph homeomorphism problem. Theoretical Computer Science, 10(2):111 – 121, 1980.
•  Marinus Gottschau, Marcus Kaiser, and Clara Waldmann. The undirected two disjoint shortest paths problem. Oper. Res. Lett., 47(1):70–75, 2019.
•  Thor Johnson, Neil Robertson, Paul D. Seymour, and Robin Thomas. Directed tree-width. J. Comb. Theory, Ser. B, 82(1):138–154, 2001.
•  Ken-ichi Kawarabayashi, Yusuke Kobayashi, and Stephan Kreutzer. An excluded half-integral grid theorem for digraphs and the directed disjoint paths problem. In STOC 2014, pages 70–78. ACM, 2014.
•  Yusuke Kobayashi and Ryo Sako. Two disjoint shortest paths problem with non-negative edge length. Oper. Res. Lett., 47(1):66–69, 2019.
•  Yusuke Kobayashi and Christian Sommer. On shortest disjoint paths in planar graphs. Discret. Optim., 7(4):234–245, 2010.
•  William Lochet. The shortest disjoint paths problem. CoRR, abs/1912.10486, 2019.
•  Raul Lopes and Ignasi Sau. A Relaxation of the Directed Disjoint Paths Problem: A Global Congestion Metric Helps. In MFCS, volume 170 of LIPIcs, pages 68:1–68:15, 2020.
•  N. Robertson and P.D. Seymour. Graph minors .xiii. the disjoint paths problem. Journal of Combinatorial Theory, Series B, 63(1):65 – 110, 1995.
•  Mohammad Ali Safari. D-width: A more natural measure for directed tree width. In MFCS, volume 3618 of Lecture Notes in Computer Science, pages 745–756. Springer, 2005.
•  Torsten Tholey. Linear time algorithms for two disjoint paths problems on directed acyclic graphs. Theor. Comput. Sci., 465:35–48, 2012.