Computing Disjoint Paths with Length Constraints

Spyros Tragoudas 1 and Yaakov L. Varol 2 Computer Science Dept., Southern Illinois University, Carbondate IL 62901, USA 2 Computer Science Dept., University of Nevada, Reno NV 89557-0148, USA A b s t r a c t . We show that the problem of computing a pair of disjoint paths between nodes s and t of an undirected graph, each having at most K, K E Z +, edges is NP-complete. A heuristic for its optimization version is given whose performance is within a constant factor from the optimal. It can be generalized to compute any constant number of disjoint paths. We also generalize an algorithm in [1] to compute the maximum number of edge disjoint paths of the shortest possible length between s and t. We show that it is NP-complete to decide whether there exist at least K, K C Z +, disjoint paths that may have at most S + 1 edges, where S is the minimum number of edges on any path between s and t. In addition, we examine a generalized version of the problem where disjoint paths are routed either between a node pair (sl, tl) or a node pair (s2, t2). We show that it is NP-hard to find the maximum number of disjoint paths that either connect pair ( s l , t l ) the shortest way or (s2, t2) the shortest way.

Introduction

We consider the problem of computing a set P of edge or node disjoint paths in an undirected graph G = (V, E) of n nodes and m edges, between nodes s, t E V, so that every p a t h p C P has bounded length. The length I(p) of a p a t h p is defined as the sum of the edges in the path. If the edges are assigned lengths w(e), then l(p) = ~ p w(e). We are interested in minimizing the quantity maxp~p l(p). We assume here that all lengths are positive integers. Edge or node disjoint paths are useful in communication networks because they ensure reliability of transmission between a source and a sink [4, 5]. In addition, bounding the length of the longest p a t h ensures that the noise interference is under control [1]. Our results are presented on edge disjoint paths but can be modified to apply to the problem of finding node disjoint paths. The special case where [PI = 2 is of particular interest. In [1] it was shown that the problem of finding a pair of bounded length edge disjoint paths is NPcomplete in a more general graph instance where the edges have been assigned lengths which are non polynomial to the input size. This is not a very realistic case, however, since in practice the weights on the edges are polynomial functions of the input size. We note t h a t the problem of computing a pair of paths is also of interest to similar problems in networking. For example, the authors of [5] have studied

376 the simpler problem of finding a pair of edge (or node) disjoint paths so that the sum of their lengths is minimum, and they present a fast polynomial time algorithm. Earlier, a less efficient polynomial time algorithm had been presented in [4] for the more generalized version where the goal is to compute k edge (or node) disjoint paths so that the sum of their lengths is minimum. Observe, however, that the problem studied in [4, 5] does not provide any guarantee on the noise interference and the algorithms in [47 5] cannot ensure any performance guarantee with respect to our objective function. In this paper (Section 2) we show that it is NP-complete to decide whether a graph G contains a pair of edge disjoint paths between s and t such that neither has more than K edges, K E Z +. This is an improvement over a weaker result in [1] for a more general problem. Moreover, we show that the algorithm in [4] serves as a heuristic for the optimization version of this problem. It finds k _> 2 edge disjoint paths pi, 1 < i < k, such that no path has total length more than k 9 O P T - k + 1, where O P T is the optimal cost. If the algorithm in [4] fails to return k paths, then the input instance does not allow for k edge disjoint paths. In Section 3, we study another problem variation. We are interested in finding the maximum possible number of edge disjoint paths whose length is less than a given bound, preferably close to the minimum possible. We present an algorithm, which generalizes an idea in [1], that finds all disjoint paths of length S, where S is the minimum length on any path between s and t. Our algorithm handles instances with arbitrary lengths on the edges whereas the algorithm in [1] has polynomial time complexity only if the lengths on the edges of G are polynomial. We also show that it is NP-complete to determine whether at least K , K E Z +, edge disjoint paths exist so that no path has more than S + 1 edges. Section 4 studies a generalized version of the problem. Here the goal is to compute edge disjoint paths connecting either node sl with tl or node s2 with t2 so that the maximum path length is minimized. It is NP-complete to determine whether there exists a path connecting sl with tl and another edge disjoint path connecting s~ with t2~ such that both paths have less than L edges, L E Z +. This problem is a generalization of the problem in Section 2. We are also interested about the variation where we want to determine if there exist at least K, K E Z +, edge disjoint paths that either connect node sl with tl in the least expensive way or node s2 with t2 in the least expensive way. We show that this problem is also NP-complete. An even more generalized variation involves k > 2 pairs (si~ t~) of source/target nodes among which we want to find edge disjoint paths. Section 5 concludes.

2 F i n d i n g two or more edge disjoint paths w i t h b o u n d e d maximum path length

We show that the following decision problem, defined on a graph G = (V, E) with unit weights on its edges, is NP-complete. Length Bounded P a i r of E d g e disjoint paths ( L B P E ) I n s t a n c e : Graph G = (V, E), specified nodes s and t, positive integer L < IVI.

377

Question: Does G contain a pair of edge disjoint paths from s to t neither involving more than L edges? We reduce from the following NP-complete problem [2].

Maximum 2-Satisfiability (MAX-2SAT)

Instance: Set U of variables, collection C of clauses over U such that each clause
c C C has Icl = 2, positive integer K < ICI. Question: Is there a truth assignment for U that simultaneously satisfies at least K of the clauses in C. T h e o r e m 1. The L B P E problem is NP-complete even for graphs with maximum

node degree 3. Proof. The problem is trivially in NP. Next, we show that the MAX-2SAT problem polynomially reduces to the L B P E problem. For the sake of simplicity, we show that the MAX-2SAT problem reduces to a modified version of the L B P E problem on G = (V,E) where the edges (u,v) E E, u,v E V, have lengths which are polynomial functions of IUI and ICt. Observe here that in the original formulation of L B P E problem each edge has unit weight. In order to be compatible with the latter, every edge (u, v) with length l(u, v) > 1 in the constructed instance below must be substituted with a path (u, Ul, u2, ..., Ull(u,v)_ll , V) consisting of II(u, v)l unit-weighted edges, and such that each node ui, 1 < i < II(u, v) - 1], has degree 2. (For the sake of simplicity, in the description of the construction below we sometimes assign polynomial weights on some edges but using this type of local transformation we always result to a graph instance with unit weights on all the edges.) Consider an arbitrary labeling of the variables and the clauses in the MAX2SAT instance, i.e., U = {ui, u2, ..., urn}, and C = {Cl, c2, ..., Cn}, where m = IUI and n = IC[. Given an instance of the MAX-2SAT problem we construct an instance of the L B P E problem as described below: G contains the special nodes s and t, and has IC[ clause components Gc~, one for each clause ci, as well as IUI variable components Guj, one for each variable uj. A clause component Gc, c E C, consists of 6 nodes. Two of the nodes are labeled ci~ and co,t. The other four nodes in Gc are related to the two literals 1t and 12 in the clause c and are called c_lk_in and c_lk_out, k = 1, 2. Thus, if x and y are two variables and the clause c is (x' + y) then the clause component Gc would have the nodes cin, Co~t, c_~'_in, c_x~_out, c_y_in, and c_y_out. With regard to the edges, Gc will have 6 inner-clause edges: (c_in, c-lk_in) (c_out, c-lk_out), of length 1, and (C_lk_in, c_lk_out) of length 4, for k = 1, 2. Furthermore, the clause components are connected with intra-clause edges: (ci_out, ci+~-in), (c~_out, t)) of length 1, and (s, cl-in) of length L1, to be specified later. Finally, there are edges of length 1 connecting the 4 nodes of the form c_l_in and c_l_out to corresponding nodes in the variable components depending on the literal assignment in c. Thus, the clause components account for 6. IC[ nodes and 6. [CI inner-clause edges, 4. ]C] edges to connect to variable components, and IC I + 1 intra-elause edges. See Fig. 1 for the structure of Go.

378 For each variable u E {ui, u2, ..., urn}, we construct a variable component G~. which has the nodes u_in and u_out, as well as, u_cj_in, u_cj_out, u'_cj_in, u'_cj_out, for 1 _< j _< [C I. In other words, each variable component has 2 + 4 . IC I nodes, and together all variable components introduce 2 -]U[ + 4 - I C ] . IU[, or 2 9m + 4 9n 9rn nodes. Let L2 be a length to be specified later. The inner-variable edges of the variable component G~ are:

9 (u_cj_in, u_cj_out) and (u'_cy_in, u~_cj_out), for j = 1, 2, ..., n, and each of

length 1.

9 (u_cj_out, u_cj+l_in) and (u'_cj_out, u'_cj+i_in), for j = 1, 2, ..., n - 1, and

each of length L >

9 (u_in, u_c,_in), (u_in, u'_cl_in), (u_c~_out, u_out), and (u s_c~_out, u_out), each
of length L2. Thus the total number of inner-variable edges in nil the variable components

is 2 . l C l . l g l

+ 2.(ICl-1).lgl

+ 4.lgl = 2-n-m+2.(n-1).m+4.m.

The following intra-variable edges connect the various variable components to each other and to s and t: (s,ul_in), (ui_out,u~+l_in) for 1 < i < m - 1, and (u,~_out, t). These ([gl + 1) = (m + 1) edges each have unit length. See Fig. 2 for the construction of variable component Gu. Finally, as mentioned earlier there are 4 9 IC[ = 4 9 n edges of length 1 connecting clause components and variable components. If a clause c has a literal l over a variable u (l is u or l is u') then the clause component Gc is connected to the variable component G~ via the edges (c_t_in, l_c_in) and (c_l_out, l_c_out). Since there are n clauses each with two literals, this amounts to 2 92. n = 4 9n edges. Thus, the total number of nodes in G for the L B P E instance being implemented is 2 + 6 9 ICI + 2 9 luI + 4. IcI. I g l = 2 + 6 9 n + 2 . m + 4 9 n m .

Furthermore, the total number of

edges in G is 11. ICI + 4-]C]. IUI + 3-IU] + 2 =

11- n + 4- n. m + 3. m + 2. Figure 3 illustrates a constructed G from a MAX-2SAT instance, where g = {u, v, w} and C = (u + v ) . (u' + v) 9 (v' + w) and K = 2. The weights L1 and L2, and the value L for the constructed instance of the L B P E decision problem on G will be set in such a way that the M A X 2SAT instance is satisfied if and only if the constructed L B P E instance on G is satisfied.i Clearly, there can only be two edge disjoint paths starting at node s. T h e p a t h t h a t starts with (S,Cl_in) will be called the clause path, and the other, starting with (s, ul_in), will be referred to as the variable path. The clause path, whose first edge has weight .L1, will be forced not to include any inner-variable edges that have length L2. Recall that at least K of the clauses in C have to be satisfied. Thus, a clause path must have at least K s u b - p a t h s of the form { ( ci_in, ci_t_in ) , (ci j_in, t_c~_in) , (l_ci_in, l_ci_out ) , (I_ci_out, ci_t_out ) , (ci_l_out, ci_out), (ci_out, ci+lAn)}, where 1 is a literal in clause ci. (If i = IcI, then ci+t-in = t.) Each such subpath is called an enforcer of clause ci and has length 6. As we show later, they guarantee that at least K clauses are

379 satisfied. The value of L2 will enforce the clause path to go through every clause component Gc, and to have at least K clause enforcers. Equivalently, a clause path may have at most I C I - K subpaths made up of inner and intra-clause edges. Such a path, which we call a non-en]orcer o] ci, has the form {(ci_in, ci_l_in), (ci_l_in, ci_l_out), (ci_l_out, ci_out), (ci_out, c~+l_in)}, where l is a literal of clause ci, and its length is 7. Such a path cannot necessarily guarantee that clause ci is satisfied. We enforce the above as follows. First we set L, the length upper bound of the LBPEinstance to be L = L1 + 6 - K + 7 - ( I C ] - K ) = LI+7-n-K, and L2 = 7 9 ICI = 7. n. Clearly, the clause path cannot include an edge with weight L2 since its length would be greater than L. (Its length would be at least L1 + 7- ICI + L2 > L.) Similarly, its length would exceed L if it has less than K clause enforcers. Having routed the clause path, the routing of the variable path is restricted. It cannot contain any clause component nodes c_in or c_out since such nodes are in the clause path and have degree 3. If the variable path contains an edge of the form (l_c_in, c_l_in), it must then follow edge (c_l_in, c_l_out) and come back to the variable component using (c_l_out, l_c_out). However, as we show later, the length assignment on LI would prevent the variable path to contain such subpaths. Thus, a variable path starting with (s, ul-in), must go through every variable component, and in each contain either all the nodes on the right or the left of Gu involving only one of the literals associated with u. In particular, if the variable path contains the nodes of G~ that correspond to nodes u~_cj_in, u~_cj_out, 1 < j < ICI, then we assign variable u to be true (and u' to be false), otherwise it is assigned to be false (and u ~ to be true). Clearly, the length of the variable path is easily shown to be precisely ((IC] + 1). L2 + ]C])-IU] + 1 + ]UI= ((n + 1). 7 . n + n ) . m + 1 + m. We would like the latter quantity to be no more than L. In fact, we insist that it be equal to L, which quickly sets the value of L1 since ((n + 1) 9 7 - n + n) 9 m + 1 + m = Ll+7"n-K, resulting in L1 = l + m - 7 . n + K + 8 . n . m + 7 . n ~.m. The rest of the proof follows directly: If the L B P E instance on G is satisfied then the MAX-2SAT instance is satisfied. Simply observe that the clause path must have at least K enforcers of clause ci. Each such subpath is satisfied by the assignment on the variable that corresponds to literal l in the clause ci. See also Fig. 4. It is also easy to see that if the MAX-2SAT instance is satisfied then one can select a clause path and a variable path as outlined above in order to satisfy the L B P E instance on G. In the remaining, we briefly show that the algorithm in [4] (or for the special case of k = 2 the algorithm in [5]) serves as an efficient heuristic for the problem of computing k edge disjoint paths so that the maximum path length is no more than k times the path length in an optimal solution. We assume that all lengths are positive integers. For this, simply observe that the algorithm in [4] returns k edge disjoint paths for which the sum of their lengths is minimum and equal to SUM_OPT. Clearly, an optimal solution to our problem has cost OPT such that OPT > SUM_OPT/k. Since all edge lengths are positive, every path has

380 length at least one and thus the most costly path in the solution returned by the algorithm in [4] has length at most S U M _ O P T - k + 1 <_ O P T . k - k + 1. If we allow for nonnegative integer weights on the edges, the same heuristic returns a bound of O P T . k. 3 Many disjoint paths of short length

Another interesting problem variation is to obtain as many short length edge disjoint paths as possible. We assume again that the lengths on the edges are positive integers. In Section 3.1 we consider the problem of finding the maximum number of paths of the shortest possible length between the source s and the destination t. Let S be the number of edges of a shortest path in G. We initially present a polynomial time algorithm that finds the maximum number of paths of length S. In Section 3.2 we examine the more generalized problem where the paths are allowed to have either length S or S+1. We show that it is an NP-complete problem to determine whether there exist at least K, K C Z +, edge disjoint paths whose length is either the shortest or one more unit than the shortest, even if all lengths on the edges are uniform. 3.1 M a n y d i s j o i n t p a t h s of s h o r t e s t l e n g t h

The algorithm that computes all edge disjoint paths of shortest length uses a Dijkstra-like computation on G. Although we assume here that all edge weights are positive integers, the algorithm of this section can be modified to handle instances where the weights are nonnegative integers. We note that in [i] an algorithm for the same problem was presented which has pseudo-polynomial worst case time complexity. Our approach consists of two phases. Phase i consists of a systematic traversal of G, starting from node s, the source. We maintain a directed graph G = (V, E) consisting of the nodes visited by our expansion algorithm, and the directed edges that reflect the direction of the traversal. Every node in G is assigned a nonnegative weight l 0 which controls the expansion procedure. G initially contains only s, the source, which is assigned a weight 0, i.e., l(s) = 0. All edges of the undirected graph G are set as unmarked. In the following description, we use (% v) to represent an undirected edge of G, and < u, v > to represent a directed edge of G from node u to node v. Phase 1 is a basic loop that every time inserts one directed edge on G. (An iteration of the loop may not necessarily add a new node on G.) The basic loop consults the weight l(v) of each node v E ~" as well as the weight w(u,v) of each unmarked edge (u, v) E E that is incident to a node already in G. We select edge < u, v > for which the sum l(u) +w(u, v) is minimum, and we mark the respective edge (u,v) E E. If node v E V then l(v) is already equal to l(u) + w(u,_v) and we simply insert edge < u,v > in /). If v ~ V, then we insert v E V, edge < u,v >E 1~, and set t(v) = t(u) + w(u,v). The process terminates when an edge (u, t) is selected, where t Js the target node, such that l(u) + w(u, t) > I(t).

381 Figure 5 illustrates the construction of G. Every directed path in G from s to any other node v E ~" is a shortest path from s to v. (The proof is similar to that for Dijkstra's shortest path algorithm and is omitted.) Note that when the weights w 0 are positive, G is acyclic. Phase 2 applies a maximum flow algorithm on G, where the capacity of each edge is set to be 1. The flow paths returned by Phase 2 form our solution. The length of each such path is S, and they form a maximum set of edge disjoint paths. We conclude: T h e o r e m 2. We can compute in polynomial time the maximum number of edge disjoint paths of shortest length between nodes s and t of a graph G. 3.2 Many non-necessarily shortest length disjoint paths

This section shows that the problem of computing the maximum number of disjoint paths is NP-hard if we allow for either paths of shortest length S or of length S + I . More precisely, we show the following theorem. T h e o r e m 3. The problem of deciding whether a graph G has K or more, K E Z +, edge disjoint paths between nodes s and t, each having at most S + 1 edges is NP-complete.
Proof. The problem is clearly in NP. The reduction is similar to that in Theorem 3.2 of [1] for a different decision problem. We reduce from a restricted version of the 3-SAT instance where the number of occurrences of variable ui in the instance is equal to that of ui. Let m, n, ri be the number of variables, clauses, and appearances of variable ui (or ui) in the 3-SAT instance, respectively. Let r = ~ i ri. This variation of 3-SAT was shown to be NP-complete in [1]. Given such an instance of 3-SAT we construct a graph G with the property that the 3-SAT instance is satisfied if and only if G has n + r edge disjoint paths of length at most S + I . Graph G contains subgraphs Gi, 1 < i < m, each associated with variable u~, that have only s and t in common. Node ui,k (resp. fi~,k) of Gi corresponds to the k th occurrence of ui (resp. ui) in the 3-SAT instance. Graph Gi consists of ri + 1 components: the a-Gi component, and ri components/3k-Gi, 1 < k < ri. Any two ~k-Gi components share node s. The ~k-Gi and a-Gi components share nodes s, Ui,k, and gi,k. Figures 6(a) and 6(b) show the a-Gi and a/3k-Gi component, respectively. Besides the latter components, G contains nodes cl, ..., Ca. It has edges (ci,t), 1 < i < n, and also (Ui,k,Cj) (resp. ((Ti,k,cj)) if the k th occurrence of ui (resp. ui) is in the jth clause. Figure 7 shows G for the 3-SAT instance (ill + u2 + u3) 9 (ul + fi2 + ~3) " (Ul + U2 + U3) " (~1 + U2 + u3)Assume that G has n + r edge disjoint paths each having at most S + 1 = 6 edges. Clearly, every path that contains edges of a/~k-Gi component must also contain some node ci, otherwise its length is more than S + 1. Since the degree of t is exactly n + r, each edge incident to t must participate in a path. These observations imply that r paths must contain nodes w~,k and Y~,k of the a_Gi

382 components, and that each a-Gi component must contribute exactly ri paths. The structure of a_Gi guarantees that for the latter to happen either all paths must contain only nodes Us,k, 1 <_ k < ri, or only nodes ~i,k. Each of the remaining n paths contains a node ci, 1 < i < n, and a node Ui,k (or fti,k) that is not participating in one of the first r paths. If ui,k (resp. ui,k) is on the same path with cj then the jth clause is satisfied by assigning ui to true (resp. false). A similar argument can be used to show that if the 3-SAT instance is satisfiable then G has n + r edge disjoint paths each having at most S + 1 edges. 4 More than one source and destination

This examines a generalized problem formulation where we want to find disjoint paths that either connect a pair of nodes sl and tl or a pair of nodes s2, t2. We show that it is an NP-complete problem to find at least K, K C Z +, shortest length edge disjoint paths connecting either sl and tl or s2 and t2. In particular we have:

It is NP-complete to decide whether a graph G has K or more, K C Z +, edge disjoint paths connecting either node sl with tl in the shortest possible way or node s2 with t2 in the shortest possible way.
Theorem4.

Proof. The proof of this theorem is along the lines of Theorem 3. In particular, we reduce from the same 3-SAT variation as in Theorem 4 and that the following modifications in the construction of Theorem 3 suffice to show Theorem 4. We relabel s as sl and t as t2. In addition, we collapse all the ai,k nodes in the ~k-G~ components to a single node s2, thus introducing parallel edges from sl to s2. Similarly, we collapse all the z i j , 1 <_ f <_ ri, nodes in the ~-Gi components to a single node tl. Again, parallel edges are introduced between t l and t2. It is easy to see that in the constructed instance the length of a shortest path between sl and t l or s2 and t2 is 5. However, using arguments as in Theorem 3 it can be easily shown that we have n + r disjoint paths either between s l and t l or between s2 and t2, each having 5 edges if and only if the 3-SAT instance is satisfiable. The above construction can be also modified to avoid parallel edges.
Another variation of this generalized problem formulation would be (following the direction of Section 2) to find a pair of disjoint paths, the first connecting nodes sl and tl and the second connecting nodes s2 and t2 such that the maximum of the two path lengths is minimized. It can be easily shown, by restriction form the L B P E problem in Section 2, that it is NP-complete to determine whether there exist two such paths so that the maximum of the two lengths is less than an integer K. In [6] a heuristic is proposed for the optimization version of this problem formulation. Finally, a generalization is to consider k > 2 pairs of nodes (si, ti), 1 <_ i <_ k, and to compute K > k disjoint paths connecting the above pairs of nodes. This is a very difficult problem, however. Note that if we insist that the paths are node disjoint it is NP-complete even to determine whether k paths exist

383 [2]. However, when k = 2 a polynomial time has been reported in [2, 3] that determines whether a graph has two node disjoint paths.

Conclusions

We have shown that it is NP-complete to determine whether a graph has two edge disjoint paths connecting nodes s and t so that each has at most K edges, / ( C Z +. However, an efficient heuristic for its optimization version is given. Although we can find, in polynomial time, the maximum number of edge disjoint paths of shortest length between s and t, it is NP-complete to determine if G has at least K , K C Z +, edge disjoint paths connecting s and t whose length does not exceed the shortest by more than one unit. We also consider a generalization where the paths are connecting either nodes sl and t l or s2 and t2. For this generalized problem, we also showed that it is NP-complete to determine whether there exist K or more, K E Z +, edge disjoint paths connecting (sl, tl) or (s2, t2) with minimum cost. All the results can be modified to apply to the similar problem of finding node disjoint paths. They can also be modified to apply to directed graphs.

References 1. Itai A., Perl Y., Shiloach Y.: The Complexity of Finding Maximum Disjoint Paths with Length Constraints. Networks 12 (1982) 277-286 2. Garey M.R., Johnson D.S.: Computers and Intractability. A Guide to the Theory of NP-Completeness. W.H. Freeman and Company, New York, NY, 1979 3. Shiloach Y.: The Two Paths Problem is Polynomially Solvable. Report STAN-CS78-654. Computer Science Department, Stanford University, Stanford, CA 4. Suurballe, J.W.: Disjoint Paths in a Network. Networks 4 (1974) 125-145 5. Suurballe, J.W., Tarjan, R.E.: A Quick Method for Finding Shortest Pairs of Disjoint Paths. Networks 14 (1984) 325-336 6. Tragoudas, S., Varol Y.L.: On the Computation of Disjoint Paths with Length Constraints. Technical Report 96-6. Computer Science Department, Southern Illinois Univerity, Carbondale, IL 62901

384

from ,revious
c_in

Gco r s
to ll_c_in

~x~-l l-in ~ ~-l l-~

c out~
to next G c or t

ll_C_OUt to 12_c_in to 12_c_out

tO

Fig. 1. Component G c
(The numbers on the edges indicate lenghts)

from S or previous

U_.OUt

u_in u-cl-tn 1~2 --~ t '-cl-in _Cl_OU i U"Cl_Ottt U--C2--" ~L2 L~ u,_c2_in
t

U_Cn_tn.

. u'_Cn_in

to n e x t

u_in o r

Fig. 2. Component G u
(The numbers on the edges indicate lenghts)

385

--

u_c
1 U_C

in ~. tr I in out -z! u '_c2_in l~ '~'-c 2-o ut ',

i

.lnout

//

u--c3-tv' u_c3_ou, u_c2_out

lpu '-c3-in
U' C3 OUt

,J'
out
in

V_C

~ . v '_c l_in ~ =v'_Cl_OUt L~ v,_c2_in

cc2-u'-u' in 2~

ITj

1
1

v_Q_c, ~ 9 V_C2 OUi

I'v'_c2_out
v '_c3_in

~v--c3-in L2

V'_C3_OUt ~v_out
1
W in

W c~ m ~
W _ r l Obll~ l

w'_ct_in
l] W" CI Obt'r

W_C2_i~2 :3 w in c3 w out
1
1

~'~ W'_C2_irl 1 w,_c2_out

w_c2_o w-c3-fit~2
q'

L2 '_c3_in ~w

1
.~h tw 1

~~L~
"~w

L2~
out

Fig. 3. The construction of G for the MAX-2SAT instance (u+v') (u'+v) (v'+w) with K=2. Thick edges have lengths greater than 1. The numbers on the edges represent lengths. L~ = 21, L 2 = 246, a n d L = 265.

386

,, ~ ,, ,, ,,s
cl-in- '~ ~ ~ ~ 1

t u-~';-~'~ v
~ ~ ~ ~ a ~ ~ --

u in

~t
L2
1

' ("1 irt - ._

U' C] Obtt

L2~u'_c2 in ~' C2 .OUt

! v'_in

u_c2_oltl u_c 3_tl~ u_c 3_ou u' c 3 in "~U'_C3._OUt

1
It 1 c 2 u' in v cI

v ci m ou

V tl~

out

c2~vdrl~ ~ ~ ~ ~

~ ~

v c20ug| 1

o~

...

,. ,.
1

v_<,_i,~ L2

I It
II

_out

I c 3_i~., $1 w c w.- L 2 ~ V , Cl_in 1 ' Cl OUt

t4

y'_oRt

w-c2-in t w c2_out 1

~W
1
l - ,u out

L2 w, c2_in 11w, c2 0u t L i I ~" c3-in c 3 out

/ 4|C3--W--OU~ w ~

W--C3--in L? ~

c3_o.r

wc3-o~t

.-4

Fig. 4. Two disjoint paths ( m m ,,, ~ , ) in the LBPE instance that have length at most L and result in satisfying the first two clauses in the MAX-2SAT instance with K = 2.

387

(a)

l(s)=O l(a)=~l(e)=4 l(b)=3 ~l(t)=5

(b)
Fig. 5. The graphs of the algorithm in Section 3.1 (a) Graph G___=(V~E) (b) Graph G=(V,E)

~4

/',,1

C:r'

(3o OO

389

al,1 bl, Wl, Ul, U1, Yl,

a31

-~1,2

Fig. 7. The complete graph G for the 3--SAT instance in the proof of Theorem 3