We study the classical NodeDisjoint Paths (NDP) problem: given an vertex graph and a collection of pairs of vertices of called demand pairs, find a maximumcardinality set of nodedisjoint paths connecting the demand pairs. NDP is one of the most basic routing problems, that has been studied extensively. Despite this, there are still wide gaps in our understanding of its approximability: the best currently known upper bound of on its approximation ratio is achieved via a simple greedy algorithm, while the best current negative result shows that the problem does not have a better than approximation for any constant , under standard complexity assumptions. Even for planar graphs no better approximation algorithms are known, and to the best of our knowledge, the best negative bound is APXhardness. Perhaps the biggest obstacle to obtaining better approximation algorithms for NDP is that most currently known approximation algorithms for this type of problems rely on the standard multicommodity flow relaxation, whose integrality gap is for NDP, even in planar graphs. In this paper, we break the barrier of on the approximability of the NDP problem in planar graphs and obtain an approximation. We introduce a new linear programming relaxation of the problem, and a number of new techniques, that we hope will be helpful in designing more powerful algorithms for this and related problems.
1 Introduction
In the NodeDisjoint Paths (NDP) problem, we are given an vertex graph , and a collection of pairs of vertices of , called sourcedestination, or demand, pairs. The goal is to route as many of the demand pairs as possible, by connecting each routed pair with a path, so that the resulting paths are nodedisjoint. We denote by NDPPlanar the special case of the problem where the input graph is planar, and by NDPGrid the special case where is the grid. NDP is one of the most basic problems in the area of graph routing, and it was initially introduced to the area in the context of VLSI design. In addition to being extensively studied in the area of approximation algorithms, this problem has played a central role in Robertson and Seymour’s Graph Minor series. When the number of the demand pairs is bounded by a constant, Robertson and Seymour [RS90, RS95] have shown an efficient algorithm for the problem, as part of the series. When is a part of input, the problem becomes NPhard [Kar72, EIS76], even on planar graphs [Lyn75], and even on grid graphs [KvL84]. Despite the importance of this problem, and many efforts, its approximability is still poorly understood. The following simple greedy algorithm achieves an approximation [KS04]: while contains any path connecting any demand pair, choose the shortest such path , add to the solution, and delete all vertices of from . Surprisingly, this elementary algorithm is the best currently known approximation algorithm for NDP, even for planar graphs. Until recently, this was also the best approximation algorithm for NDPGrid. On the negative side, it is known that there is no approximation algorithm for NDP for any constant , unless [AZ05, ACG10]. To the best of our knowledge, the best negative result for NDPPlanar and for NDPGrid is APXhardness [CK15]. Perhaps the biggest obstacle to obtaining better upper bounds on the approximability of NDP is that the common approach to designing approximation algorithms for this type of problems is to use the multicommodity flow relaxation, where instead of connecting the demand pairs with paths, we send a (possibly fractional) multicommodity flow between them. The integrality gap of this relaxation is known to be , even for planar graphs, and even for grid graphs. In a recent work, Chuzhoy and Kim [CK15] showed an approximation algorithm for NDPGrid, thus bypassing the integrality gap obstacle for this restricted family of graphs. The main result of this paper is an approximation algorithm for NDPPlanar. We also show that, if the value of the optimal solution to the NDPPlanar instance is , then we can efficiently route demand pairs. Our algorithm is motivated by the work of [CK15] on NDPGrid, and it relies on approximation algorithms for the NDP problem on a disc and on a cylinder, that we discuss next.
We start with the NDP problem on a disc, that we denote by NDPDisc. In this problem, we are given a planar graph , together with a set of demand pairs as before, but we now assume that can be drawn in a disc, so that all vertices participating in the demand pairs lie on its boundary. The NDP problem on a cylinder, NDPCylinder, is defined similarly, except that now we assume that we are given a cylinder , obtained from the sphere, by removing two disjoint open discs (caps) from it. We denote the boundaries of the discs by and respectively, and we call them the cuffs of . We assume that can be drawn on , so that all source vertices participating in the demand pairs in lie on , and all destination vertices lie on . Robertson and Seymour [RS86] showed an algorithm, that, given an instance of the NDPDisc or the NDPCylinder problem, decides whether all demand pairs in can be routed simultaneously via nodedisjoint paths, and if so, finds the routing efficiently. Moreover, for each of the two problems, they give an exact characterization of instances for which all pairs in can be routed in . Several other very efficient algorithms are known for both problems [RLWW96, SAN90]. However, for our purposes, we need to consider the optimization version of both problems, where we are no longer guaranteed that all demand pairs in can be routed, and would like to route the largest possible subset of the demand pairs. We are not aware of any results for these two special cases of the NDP problem. In this paper, we provide approximation algorithms for both problems.
Other Related Work.
A problem closely related to NDP is the EdgeDisjoint Paths (EDP) problem. It is defined similarly, except that now the paths chosen to the solution are allowed to share vertices, and are only required to be edgedisjoint. It is easy to show, by using a line graph of the EDP instance, that NDP is more general than EDP (though this transformation inflates the number of the graph vertices, so it may not preserve approximation factors that depend on ). This relationship breaks down in planar graphs, since the resulting NDP instance may no longer be planar. The approximability status of EDP is very similar to that of NDP: there is an approximation algorithm [CKS06], and it is known that there is no approximation algorithm for any constant , unless [AZ05, ACG10]. We do not know whether our techniques can be used to obtain improved approximation algorithms for EDP on planar graphs. As in the NDP problem, we can use the standard multicommodity flow LPrelaxation of the problem, in order to obtain an approximation algorithm, and the integrality gap of the LPrelaxation is even in planar graphs. For several special cases of the problem better algorithms are known: Kleinberg [Kle05], building on the work of Chekuri, Khanna and Shepherd [CKS05, CKS04], has shown an approximation LProunding algorithm for evendegree planar graphs. Aumann and Rabani [AR95] showed an approximation algorithm for EDP on grid graphs, and Kleinberg and Tardos [KT98, KT95] showed approximation algorithms for broader classes of nearlyEulerian uniformly highdiameter planar graphs, and nearlyEulerian densely embedded graphs. Recently, Kawarabayashi and Kobayashi [KK13] gave an approximation algorithm for EDP when the input graph is either 4edgeconnected planar or Eulerian planar. It appears that the restriction of the graph to be Eulerian, or nearlyEulerian, makes the EDP problem significantly simpler, and in particular improves the integrality gap of the LPrelaxation. The analogue of the grid graph for the EDP problem is the wall graph: the integrality gap of the standard LPrelaxation for EDP on wall graphs is , and until recently, no better than approximation algorithms for EDP on walls were known. The work of [CK15] gives an approximation algorithm for EDP on wall graphs.
A variation of the NDP and EDP problems, where small congestion is allowed, has been a subject of extensive study. In the NDP with congestion (NDPwC) problem, the input is the same as in the NDP problem, and we are additionally given a nonnegative integer . The goal is to route as many of the demand pairs as possible with congestion at most : that is, every vertex may participate in at most paths in the solution. EDP with Congestion (EDPwC) is defined similarly, except that now the congestion bound is imposed on edges and not vertices. The classical randomized rounding technique of Raghavan and Thompson [RT87] gives a constantfactor approximation for both problems, if the congestion is allowed to be as high as . A recent line of work [CKS05, Räc02, And10, RZ10, Chu12, CL12, CE13, CC] has lead to an approximation for both NDPwC and EDPwC problems, with congestion . For planar graphs, a constantfactor approximation with congestion 2 is known for EDP [SCS11]. All these algorithms perform LProunding of the standard multicommodity flow LPrelaxation of the problem and so it is unlikely that they can be extended to routing with no congestion.
Our Results and Techniques.
Given an instance of the NDP problem, we denote by the value of the optimal solution to it. Our first result is an approximation algorithm for NDPDisc and NDPCylinder.
Theorem 1.1
There is an efficient approximation algorithm for the NDPDisc and the NDPCylinder problems, where is the number of the demand pairs in the instance.
We provide a brief highlevel overview of the techniques we use in the proof of Theorem 1.1. We define a new intermediate problem, called Demand Pair Selection Problem (DPSP). In this problem, we are given two disjoint directed paths and , and a set of pairs of vertices that we call demand pairs, such that all vertices in lie on , and all vertices in lie on . For any pair of vertices , we denote if lies before on , and we denote if or . For every pair of vertices, we define the relationships and similarly. We say that two demand pairs cross, if either (i) , or (ii) and , or (iii) and . We are also given a set of constraints that we describe below. The goal of the DPSP problem is to find a maximumcardinality subset of demand pairs, such that no two pairs in cross, and all constraints in are satisfied. There are four types of constraints in , and each constraint is defined by a quadruple , where is the constraint type, are vertices, and is an integer. In a type1 constraint , we have , and the constraint requires that the number of the demand pairs with is at most . Similarly, in a type2 constraint , we have , and the constraint requires that the number of the demand pairs with is at most . If is a type3 constraint, then and must hold. The constraint requires that the number of the demand pairs with and is at most . Similarly, if is a type4 constraint, then and must hold, and the constraint requires that the number of the demand pairs with and is at most . We show that both NDPDisc and NDPCylinder reduce to DPSP with an loss in the approximation factor. The reduction from NDPDisc to DPSP uses the characterization of routable instances of NDPDisc due to Robertson and Seymour [RS86]. Finally, we show a factor approximation algorithm for the DPSP problem.
The main result of our paper is summarized in the following two theorems.
Theorem 1.2
There is an efficient approximation algorithm for the NDPPlanar problem.
Theorem 1.3
There is an efficient algorithm, that, given an instance of NDPPlanar, computes a routing of demand pairs of via nodedisjoint paths in .
Notice that when is small, Theorem 1.3 gives a much better that approximation.
We now give a highlevel intuitive overview of the proof of Theorem 1.2. Given an instance of the NDP problem, we denote by the set of vertices participating in the demand pairs in , and we refer to them as terminals. We start with a quick overview of the approximation algorithm of [CK15] for the NDPGrid problem, since their algorithm was the motivation for this work. The main observation of [CK15] is that the instances of NDPGrid, for which the multicommodity flow relaxation exhibits the integrality gap, have terminals close to the grid boundary. When all terminals are at a distance of at least from the boundary of the grid, one can find an approximation via LProunding (but unfortunately the integrality gap remains polynomial in even in this case). When the terminals are close to the grid boundary, the integrality gap of the LPrelaxation becomes . However, this special case of NDPGrid can be easily approximated via simple dynamic programming. For example, when all terminals lie on the grid boundary, the integrality gap of the LPrelaxation is , but a constantfactor approximation can be achieved via standard dynamic programming. More generally, when all terminals are within distance at most from the grid boundary, we can obtain an approximation via dynamic programming. Overall, we partition the demand pairs of into two subsets, depending on whether the terminals lie close to or far from the grid boundary, and obtain an approximation for each of the two resulting problem instances separately, selecting the better of the two solutions as our output.
This idea is much more difficult to implement in general planar graphs. For one thing, the notion of the “boundary” of a planar graph is meaningless  any face in the drawing of the planar graph can be chosen as the outer face. We note that the standard multicommodity flow LPrelaxation performs poorly not only when all terminals are close to the boundary of a single face (a case somewhat similar to NDPDisc), but also when there are two faces and , and for every demand pair , is close to the boundary of and is close to the boundary of (this setting is somewhat similar to NDPCylinder). The notion of “distance”, when deciding whether the terminals lie close to or far from a face boundary is also not welldefined, since we can subdivide edges and artificially modify the graph in various ways in order to manipulate the distances without significantly affecting routings. Intuitively, we would like to define the distances between the terminals in such a way that, on the one hand, whenever we find a set of demand pairs, such that all terminals participating in the pairs in are far enough from each other, then we can route a large subset of the demand pairs in . On the other hand, if we find a set of demand pairs, with all terminals participating in the pairs in being close to the boundary of some face (or a pair of faces), then we can find a good approximate solution to instance (for example, by reducing the problem to NDPDisc or NDPCylinder). Since we do not know beforehand which face (or faces) will be chosen as the “boundary” of the graph, we cannot partition the problem into two subproblems and employ different techniques to solve each subproblem as we did for NDPGrid. Instead, we need a single framework in which both cases can be handled.
We assume that every terminal participates in exactly one demand pair, and that the degree of every terminal is . This can be achieved via a standard transformation, where we create several copies of each terminal, and connect them to the original terminal. This transformation may introduce up to new vertices. Since we are interested in obtaining an approximation for NDPPlanar, we denote by the number of the nonterminal vertices in the new graph . Abusing the notation, we denote the total number of vertices in the new problem instance by . It is now enough to obtain an approximation for the new problem instance.
Our first step is to define a new LPrelaxation of the problem. We assume that we have guessed correctly the value of the optimal solution. We start with the standard multicommodity flow LPrelaxation, where we try to send flow units between the demand pairs, so that the maximum amount of flow through any vertex is bounded by . We then add the following new set of constraints to the LP: for every subset of the demand pairs, for every value , the total amount of flow routed between the demand pairs in is no more than . Adding this type of constraints may seem counterintuitive. We effectively require that the LP solves the problem exactly, and naturally we cannot expect to be able to do so efficiently. Since the number of the resulting constraints is exponential in , and since we do not know the values , we indeed cannot solve this LP efficiently. In fact, our algorithm does not attempt to solve the LP exactly. Instead, we employ the Ellipsoid algorithm, that in every iteration produces a potential solution to the LPrelaxation. We then show an algorithm that, given such a potential solution, either finds an integral solution routing demand pairs, or it returns some subset of demand pairs, whose corresponding LPconstraint is violated. Therefore, we use our approximation algorithm as the separation oracle for the Ellipsoid algorithm. We are then guaranteed that after iterations, we will obtain a solution routing the desired number of demand pairs, as only iterations are required for the Ellipsoid algorithm in order to find a feasible LPsolution.
The heart of the proof of Theorem 1.2 is then an algorithm that, given a potential (possibly infeasible) solution to the LPrelaxation, either finds an integral solution routing demand pairs, or returns some subset of demand pairs, whose corresponding LPconstraint is violated. We can assume without loss of generality that the fractional solution we are given satisfies all the standard multicommodity flow constraints, as this can be verified efficiently. For simplicity of exposition, we assume that every demand pair in sends the same amount of flow units to each other.
We assume for now that the set of terminals is welllinked, for  that is, for every pair of disjoint equalsized subsets of vertices of , we can connect vertices of to vertices of by at least nodedisjoint paths. We discuss this assumption in more detail below. We assume that we are given a drawing of on the sphere. Our first step is to define the notion of distances between the terminals. In order to do so, we first construct enclosures around them. Throughout the proof, we use a parameter . We say that a curve on the sphere is a normal curve iff it intersects the drawing of only at its vertices. The length of such a curve is the number of vertices of it contains. An enclosure around a terminal is a disc containing , whose boundary, that we denote by , is a normal curve of length exactly , so that at most terminals lie in . We show an efficient algorithm to construct the enclosures around the terminals , so that the following additional conditions hold: (i) if for any pair of terminals, then ; and (ii) if , then there are nodedisjoint paths connecting the vertices of to the vertices of . We now define the distances between pairs of terminals. For every pair , distance is the length of the shortest normal curve, connecting a vertex of to a vertex of .
Next, we show that one of the following has to happen: either there is a large collection of demand pairs, such that all terminals participating in the pairs in are at a distance at least from each other; or there is a large collection of demand pairs, and two faces in the drawing of (with possibly ), such that for every demand pair in , one of its terminals is within distance at most from the boundary of , and the other is within distance at most from the boundary of . In the former case, we show that we can route a large subset of the demand pairs in via nodedisjoint paths, by constructing a special routing structure called a crossbar (this construction exploits welllinkedness of the terminals and the paths connecting the enclosures). In the latter case, we reduce the problem to NDPDisc or NDPCylinder, depending on the distance between the faces and , and employ the approximation algorithms for these problems to route demand pairs from in . If the resulting number of demand pairs routed is close enough to , then we return this as our final solution. Otherwise, we show that the LPconstraint corresponding to the set of demand pairs is violated, or equivalently, the amount of flow sent by the LP solution between the demand pairs in is greater than .
So far we have assumed that the terminals participating in the demand pairs in are welllinked. In general this may not be the case. Using standard techniques, we can perform a welllinked decomposition: that is, compute a subset of at most vertices, such that, if we denote the set of all connected components of by , and for each , we denote by the set of the demand pairs contained in , then the terminals participating in the demand pairs in are welllinked in . We are then guaranteed that . It is then tempting to apply the algorithm described above to each of the graphs separately. Indeed, if, for each , we find a set of nodedisjoint paths, routing demand pairs of in (where denotes the number of the nonterminal vertices in ), then we obtain an approximate solution overall. Assume now that for some , we find a subset of demand pairs, such that . Unfortunately, the set of demand pairs does not necessarily define a violated LPconstraint, since it is possible that , if the optimal routing uses many vertices of (and possibly from some other graphs ). In general, the number of vertices in set is relatively small compared to , so in the global accounting across all instances , only a small number of paths can use the vertices of . But for any specific instance , it is possible that most paths in the optimal solution to instance use the vertices of . In order to overcome this difficulty, we need to perform a careful global accounting across all resulting instances .
Organization
We start with preliminaries in Section 2. Section 3 is devoted to the proof of Theorem 1.1. Since this is not our main result, and the proof is somewhat long (though not very difficult), most of the proof appears in Section B of the Appendix. Sections 4–7 are devoted to the proof of Theorem 1.2: Section 4 provides an overview of the algorithm and some initial steps; Section 5 introduces the main technical tools that we use: enclosures, shells, and a partition of the terminals into subsets; and Sections 6 and 7 deal with Case 1 (when many terminals are far from each other) and Case 2 (when many terminals are close to the boundaries of at most two faces), respectively. We prove Theorem 1.3 in Section 8, and provide conclusions in Section 9. For convenience, we include in Section D of the Appendix a table of the main parameters used in the proof of Theorem 1.2.
2 Preliminaries
Given a graph and a subset of its vertices, we denote by the set of all neighbors of , that is, all vertices , such that there is an edge for some . We say that two paths and are internally disjoint iff for every vertex , is an endpoint of both and . Given a path and a subset of vertices of , we say that is internally disjoint from iff every vertex in is an endpoint of . Similarly, is internally disjoint from a subgraph of iff is internally disjoint from . Given a graph and a set of demand pairs in , for every subset of the demand pairs, we denote by the set of all vertices participating in the demand pairs in . For a subset of the demand pairs, and a subgraph , let denote the value of the optimal solution to instance .
Given a drawing of any planar graph in the plane, and given any cycle in , we denote by the unique disc in the plane whose boundary is . Similarly, if is a closed simple curve in the plane, is the unique disc whose boundary is . When the graph is drawn on the sphere, there are two discs whose boundaries are . In such cases we will explicitly specify which of the two discs we refer to. Given any disc (in the plane or on the sphere), we use to denote the disc without its boundary. We say that a vertex of belongs to disc , and denote , if is drawn inside or on its boundary.
Given a planar graph , drawn on a surface , we say that a curve in is normal, iff it intersects the drawing of at vertices only. The set of vertices of lying on is denoted by , and the length of is . For any disc , whose boundary is a normal curve, we denote by the set of all vertices of lying inside or on its boundary.
Definition 2.1
Let be two curves in the plane or on the sphere. We say that and cross, iff there is a disc , whose boundary is a simple closed curve that we denote by , such that:

is a simple open curve, whose endpoints we denote by and ;

is a simple open curve, whose endpoints we denote by and ; and

, and they appear on in this circular order.
Given a graph embedded in the plane or on the sphere, we say that two paths in cross iff their images cross. Similarly, we say that a path crosses a curve iff the image of crosses .
Sparsest Cut.
In this paper we use the node version of the sparsest cut problem, defined as follows. Suppose we are given a graph with a subset of its vertices called terminals. A vertex cut is a tripartition of , such that there are no edges in with one endpoint in and another in . If , then the sparsity of the cut is . The sparsest cut in with respect to the set of terminals is a vertex cut with , whose sparsity is the smallest among all such cuts. Amir, Krauthgamer and Rao [AKR03] showed an efficient algorithm, that, given any planar graph with a set of terminal vertices, computes a vertex cut in , whose sparsity with respect to is within a constant factor of the optimal one. We denote this algorithm by , and the approximation factor it achieves by , so is a universal constant.
In the special case of the sparsest cut problem that we consider in our paper, all terminals have degree , and no edge of connects any pair of terminals. We show that in this case we can compute a nearoptimal solution to the sparsest cut problem with . The proof of the following observation uses standard techniques and is deferred to the Appendix.
Observation 2.1
Let be a planar graph and let be a subset of its vertices called terminals, with . Assume that the degree of every terminal is , and no edge of connects any pair of terminals. Then there is an efficient algorithm to compute a vertex cut in , whose sparsity is within a factor of the optimal one, and .
Nested Segments.
Suppose we are given a graph , a cycle in , and a collection of (not necessarily disjoint) segments of , where each segment is either itself, or a subpath of . We say that is a nested set of segments of iff for all , either , or , or and are internally disjoint  that is, every vertex in is an endpoint of both segments. We define a set of nested segments of a closed curve , and of a path in similarly.
Decomposition of Forests.
A directed forest is a disjoint union of arborescences for some , where in each arborescence , all edges are directed towards the root. We use the following simple claim about partitioning directed forests into collections of paths. Similar decompositions were used in previous work, see e.g. Lemma 3.5 in [Kle05]. The proof is included in Appendix for completeness.
Claim 2.2
There is an efficient algorithm, that, given a directed forest with vertices, computes a partition of into subsets, such that for each , is a collection of disjoint directed paths, that we denote by . Moreover, for all , if there is a directed path from to in , then they both lie on the same path in .
Routing on a Disc.
Assume that we are given an instance of the NDPDisc problem, where is drawn in a disc whose boundary is denoted by . We need the following two definitions.
Definition 2.2
We say that two demand pairs cross iff either , or appear on in this circular order. We say that the set of demand pairs is noncrossing if no two demand pairs in cross.
Definition 2.3
Let be a closed simple curve and a set of demand pairs with all vertices of lying on . We say that is an split collection of demand pairs with respect to , iff there is a partition of the demand pairs in , and there is a partition of into disjoint segments, such that appear on in this circular order, and for each , for every demand pair , either and , or vice versa.
Finally, the following lemma allows us to partition any set of demand pairs into a small collection of split sets. The proof appears in the Appendix.
Lemma 2.3
There is an efficient algorithm, that, given a closed simple curve in the plane and a set of demand pairs, whose corresponding terminals lie on , computes a partition of , such that for each , set is split with respect to for some integer .
Routing on a Cylinder.
Assume that we are given an instance of the NDPCylinder problem, where and are the cuffs of the cylinder.
Definition 2.4
We say that a set of demand pairs is noncrossing if there is an ordering of the demand pairs in , such that are all distinct and appear in this counterclockwise order on , and are all distinct and appear in this counterclockwise order on .
It is immediate to verify that if we are given any instance of NDPCylinder, and any set of demand pairs that can all be routed via nodedisjoint paths in , then set is noncrossing.
Tight Concentric Cycles.
We start with the following definition.
Definition 2.5
Given a planar graph drawn in the plane and a vertex that is not incident to the infinite face, is the cycle in , such that: (i) ; and (ii) among all cycles satisfying (i), is the one for which is minimal inclusionwise.
It is easy to see that is uniquely defined. Indeed, consider the graph , and the face in the drawing of where used to reside. Then the boundary of contains exactly one cycle with containing , and . We next define a family of tight concentric cycles.
Definition 2.6
Suppose we are given a planar graph , an embedding of in the plane, a simple closed normal curve , and an integral parameter . A family of tight concentric cycles around is a sequence of disjoint simple cycles in , with the following properties:

;

if is the graph obtained from by contracting all vertices lying in into a supernode , then ; and

for every , if is the graph obtained from by contracting all vertices lying in into a supernode , then .
We will sometimes allow to be a simple cycle in . The family of tight concentric cycles around is then defined similarly.
Monotonicity of Paths and Cycles.
Suppose we are given a planar graph , embedded into the plane, a simple normal curve in , and a family of tight concentric cycles around . Assume further that we are given a set of nodedisjoint paths, originating at the vertices of , and terminating at some vertices lying outside of . We would like to reroute these paths to ensure that they are monotone with respect to the cycles, that is, for all , and for all , is a path. We first discuss rerouting to ensure monotonicity with respect to a single cycle, and then extend it to monotonicity with respect to a family of concentric cycles.
Definition 2.7
Given a graph , a cycle and a path in , we say that is monotone with respect to , iff is a path.
The proof of the following lemma is deferred to the Appendix.
Lemma 2.4
Let be a planar graph embedded into the plane, a simple cycle in , and a collection of simple internally nodedisjoint paths between two vertices: vertex lying in , and vertex , that is incident on the outer face. Assume further that is the union of and the paths in , and that . Then there is an efficient algorithm to compute a set of internally nodedisjoint paths connecting to in , such that every path in is monotone with respect to .
We now define monotonicity with respect to a family of cycles.
Definition 2.8
Let be a graph, a collection of disjoint cycles, and a collection of nodedisjoint paths in . We say that the paths in are monotone with respect to , iff for every , every path in is monotone with respect to .
The following theorem allows us to reroute sets of paths so they become monotone with respect to a given family of tight concentric cycles. Its proof is a simple application of Lemma 2.4 and is deferred to the Appendix.
Theorem 2.5
Let be a planar graph embedded in the plane, any simple closed normal curve or a simple cycle in , and a family of tight concentric cycles in around . Let be any connected subgraph of lying completely outside of , and let be a set of nodedisjoint paths, connecting a subset of vertices to a subset of vertices, so that the paths of are internally disjoint from . Let . Then there is an efficient algorithm to compute a collection of nodedisjoint paths in , connecting the vertices of to the vertices of , so that the paths in are monotone with respect to , and they are internally nodedisjoint from .
3 Routing on a Disc and on a Cylinder
In this section we prove Theorem 1.1. In order to do so, we define a new problem, called Demand Pair Selection Problem (DPSP), and show an approximation algorithm for it. We then show that both NDPDisc and NDPCylinder reduce to DPSP.
Demand Pair Selection Problem
We assume that we are given two disjoint directed paths, and , and a collection of pairs of vertices of that are called demand pairs, where all vertices of lie on , and all vertices of lie on (not necessarily in this order). We refer to the vertices of and as the source and the destination vertices, respectively. Note that the same vertex of may participate in several demand pairs, and the same is true for the vertices of . Given any pair of vertices of , with lying before on , we sometimes denote by the subpath of between and (that includes both these vertices), and we will sometimes refer to it as an interval. We define intervals of similarly.
For every pair of vertices, we denote if lies strictly before on , and we denote , if or hold. Similarly, for every pair of vertices, we denote if lies strictly before on , and we denote , if or hold. We need the following definitions.
Definition 3.1
Suppose we are given two pairs and of vertices of , with and . We say that and cross iff one of the following holds: either (i) ; or (ii) ; or (iii) and ; or (iv) and .
Definition 3.2
We say that a subset of demand pairs is noncrossing iff for all distinct pairs , and do not cross.
Our goal is to select the largestcardinality noncrossing subset of demand pairs, satisfying a collection of constraints. Set of constraints is given as part of the problem input, and consists of four subsets, , where constraints in set are called typei constraints. Every constraint is specified by a quadruple , where is the constraint type, , and is an integer.
For every type1 constraint , we have with . The constraint is associated with the subpath of . We say that a subset of demand pairs satisfies iff the total number of the source vertices participating in the demand pairs of that lie on is at most .
Similarly, for every type2 constraint , we have with , and the constraint is associated with the subpath of . A set of demand pairs satisfies iff the total number of the destination vertices participating in the demand pairs in that lie on is at most .
For each type3 constraint , we have and . The constraint is associated with the subpath of between the first vertex of and (including both these vertices), and the subpath of between and the last vertex of (including both these vertices). We say that a demand pair crosses iff and . A set of demand pairs satisfies iff the total number of pairs that cross is bounded by .
Finally, for each type4 constraint , we also have and . The constraint is associated with the subpath of between and the last vertex of (including both these vertices), and the subpath of between the first vertex of and (including both these vertices). We say that a demand pair crosses iff and . A set of demand pairs satisfies iff the total number of pairs that cross is bounded by .
Given the paths , the set of the demand pairs, and the set of constraints as above, the goal in the problem is to select a maximumcardinality noncrossing subset of demand pairs, such that all constraints in are satisfied by . The proof of the following theorem is deferred to the Appendix.
Theorem 3.1
There is an efficient approximation algorithm for DPSP.
We then use Theorem 3.1 in order to design approximation algorithms for NDPDisc and NDPCylinder. The remainder of the proof of Theorem 1.1 appears in Section B of the Appendix. The algorithm for NDPDisc exploits the exact characterization of routable instances of the problem given by Robertson and Seymour [RS86], in order to reduce the problem to DPSP. The algorithm for NDPCylinder reduces the problem to NDPDisc and DPSP.
4 Algorithm Setup
The rest of this paper mostly focuses on proving Theorem 1.2; we prove Theorem 1.3 using the techniques we employ for the proof of Theorem 1.2 in Section 8.
We assume without loss of generality that the input graph is connected  otherwise we can solve the problem separately on each connected component of . Let . It is convenient for us to assume that every terminal participates in exactly one demand pair, and that the degree of every terminal is . This can be achieved via a standard transformation of the input instance, where we add a new collection of terminals, connecting them to the original terminals. This transformation preserves planarity, but unfortunately it can increase the number of the graph vertices. If the original graph contained vertices, then can be as large as , and so the new graph may contain up to vertices, while our goal is to obtain an approximation. In order to overcome this difficulty, we denote by the number of the nonterminal vertices in the new graph , so is bounded by the total number of vertices in the original graph, and by the total number of all vertices in the new graph, so . Our goal is then to obtain an efficient approximation for the new problem instance. From now on we assume that every terminal participates in exactly one demand pair, and the degree of every terminal is . If is a demand pair, then we say that is the mate of , and is the mate of . We denote . Throughout the algorithm, we define a number of subinstances of the instance , but we always use to denote the number of the demand pairs in this initial instance. We can assume that , as otherwise we can return a routing of a single demand pair.
We assume that we are given a drawing of on the sphere. Throughout the algorithm, we will sometimes select some face of as the outer face, and consider the resulting planar drawing of .
4.1 LPRelaxations
Let us start with the standard multicommodity flow LPrelaxation of the problem. Let be the directed graph, obtained from by bidirecting its edges. For every edge , for each , there is an LPvariable , whose value is the amount of the commodity flow through edge . We denote by the total amount of commodity flow sent from to . For every vertex , let and denote the sets of its outgoing and incoming edges, respectively. We denote . The standard LPrelaxation of the NDP problem is as follows.
(LPflow1)  
s.t.  
We will make two changes to (LPflow1). First, we will assume that we know the value of the optimal solution, and instead of the objective function, we will add the constraint . We can do so using standard methods, by repeatedly guessing the value and running the algorithm for each such value. It is enough to show that the algorithm routes demand pairs, when the value is guessed correctly.
Recall that for a subset of the demand pairs, and a subgraph , denotes the value of the optimal solution to instance . For every subset of the demand pairs, we add the constraint that the total flow between all pairs in is no more than , for all integers between and . We now obtain the following linear program that has no objective function, so we are only interested in finding a feasible solution.
(LPflow2)  (1)  
(2)  
(3)  
(4)  
(5)  
(6) 
We say that a solution to (LPflow2) is semifeasible iff all constraints of types (1)–(4) and (6) are satisfied. Notice that the number of the constraints in (LPflow2) is exponential in . In order to solve it, we will use the Ellipsoid Algorithm with a separation oracle, where our approximation algorithm itself will serve as the separation oracle. This is done via the following theorem, which is our main technical result.
Theorem 4.1
There is an efficient algorithm, that, given any semifeasible solution to (LPflow2), either computes a routing of at least demand pairs of via nodedisjoint paths, or returns a constraint of type (5), that is violated by the current solution.
We can now obtain an approximation algorithm for NDPPlanar via the Ellipsoid algorithm. In every iteration, we start with some semifeasible solution to (LPflow2), and apply the algorithm from Theorem 4.1 to it. If the outcome is a solution routing at least demand pairs in , then we obtain the desired approximate solution to the problem, assuming that was guessed correctly. Otherwise, we obtain a violated constraint of type (5), and continue to the next iteration of the Ellipsoid Algorithm. Since the Ellipsoid Algorithm is guaranteed to terminate with a feasible solution after a number of iterations that is polynomial in the number of the LPvariables, this gives an algorithm that is guaranteed to return a solution of value in time . From now on we focus on proving Theorem 4.1.
We note that, using standard techniques, we can efficiently obtain a flowpaths decomposition of any semifeasible solution to (LPflow2): we can efficiently find, for every demand pair , a collection of paths, connecting to , and for each path , compute a value , such that:

For each , ;

For each , ; and

For each , .
It is sometimes more convenient to work with the above flowpaths decomposition version of a given semifeasible solution to (LPflow2).
We now assume that we are given some semifeasible solution to (LPflow2), and define a new fractional solution based on it, where the flow between every demand pair is either or , for some value . First, for each demand pair with , we set and we set the corresponding flow values for all edges to . Since we can assume that if the graph is connected, the total amount of flow between the demand pairs remains at least . We then partition the remaining demand pairs into subsets, where for , set contains all demand pairs with . There is some index , such that the total flow between the demand pairs in is at least . Let . We further modify the LPsolution, as follows. First, for every demand pair , we set , and the corresponding flow values for all edges to . Next, for every demand pair , we let , so . We set , and the new flow values are obtained by scaling the original values by factor . This gives a new solution to (LPflow2), that we denote by . The total amount of flow sent in this solution is , and it is easy to verify that constraints (2)–(4) and (6) are satisfied. For every demand pair , , and for all other demand pairs , . It is easy to see that for every demand pair , . Therefore, if we find a constraint of type (5) that is violated by the new solution, then it is also violated by the old solution. Our goal now is to either find an integral solution routing