Download Approximation Algorithms: Edge Disjoint Paths and Dynamic Programming and more Study notes Approximation Algorithms in PDF only on Docsity!
CS880: Approximations Algorithms
Scribe: Siddharth Barman Lecturer: Shuchi Chawla Topic: Edge Disjoint Paths; Dynamic Programming Date: 02/01/
In this lecture we give an algorithm for Edge disjoint paths problem and then discuss dynamic programming.
4.1 Edge disjoint paths
Problem Statement: Given a directed graph G and a set of terminal pairs {(s 1 , t 1 ), (s 2 , t 2 ), · · · , (sk, tk)}, our goal is to connect as many pairs as possible using non edge intersecting paths.
Edge disjoint paths problem is N P-Complete and is closely related to the multicommodity flow problem. In fact integer multicommodity flow is a generalization of this problem. We describe a greedy approximation algorithm for the edge disjoint path problem due to Jon Kleinberg [4].
Algorithm: Compute shortest path distance between every (si, ti) pair. Route the one with smallest distance along the corresponding shortest path, remove all the used edges from the graph and repeat.
Theorem 4.1.1 The above algorithm achieves an O(
m) approximation, where m is the number of edges in the given graph.
Before we dwell on the proof of the above theorem we present an instance of the problem (Figure
- for which the greedy algorithm gives an Ω(
m) approximation. This shows that the analysis is in fact tight.
See Figure 1; The graph is constructed such that the length of the path between terminal vertices sl+1, tl+1 is smaller than all other (si, ti) paths. Hence the greedy algorithm picks the path con- necting sl+1 and tl+1 at the first go. This in turn disconnects all other terminal pairs. Thus the greedy algorithm returns a single path, but we can connect (si, ti) pairs for all i between 1 and l by edge disjoint paths.
Note that for the construction to go through length of the path between sl+1 and tl+1 must be at least l and so the length of the shortest path between si and ti for 1 ≤ i ≤ l must be more than l. So m = O(l^2 ) and the approximation achieved is l = Ω(
m).
Relation between the optimal solution and our greedy algorithm is achieved by charging each path in OP T to the first path in ALG that intersects it. For this we define short and long paths. A short path is one which has no more than k edges. Rest of the paths shall be referred to as long paths. We will pick an approximate value of k later.
Lemma 4.1.2 OP T has no more than m/k long paths, where m is the number of edges.
Proof: The paths in OP T are edge disjoint hence m/k paths of length more than k will cover all the m edges.
Lemma 4.1.3 Each short path in OP T gets charged to some short path in ALG.
Proof: The greedy algorithm picks the shortest path which is still available. Say PG is the path
l+
s
s
s
s
s
1
2
3
l
l+
t
t
t
t
t (^1)
2
3
l
Figure 4.1.1: Bad example for greedy algorithm
picked up ALG that “cuts” POP T a fixed short path in OP T for the first time. As described earlier POP T gets charged to PG. At that point of time all of previously selected paths of ALG are edge disjoint with POP T , hence POP T is still available, but ALG decides to choose PG which implies that length of PG is less than k, i.e. it is a short path.
Lemma 4.1.4 Each short path in ALG gets charged at most k times.
Proof: Paths of OP T are edge disjoint themselves hence in the worst case each edge of a short path selected by ALG cuts a different path of OP T. This bound the charge to k.
Next we use the above mentioned lemmas to prove Theorem 4. 1 .1.
Proof of Theorem 4. 1. 1 : We partition the optimal solution in long and short paths i.e. OP T = OP Tlong + OP Tshort. By lemma 4. 1 .2 we have that OP Tlong is at most m/k and using the other two lemmas we can bound OP Tshort by ALG × k. Hence,
OP T ≤
m k
Setting k =
m and noting that ALG ≥ 1 we get
OP T ≤ 2
m × ALG
Hence the algorithm achieves an approximation factor of 2
m.
The above algorithm and analysis is from Kleinberg’s thesis [4]. Chekuri and Khanna [2] gave a better analysis of the same algorithm in terms of the number of vertices of the graph. In particular they showed that the greedy algorithm achieves an approximation of O(n^4 /^5 ) in general and an O(n^2 /^3 ) approximation for undirected graphs.
Surprisingly with complexity theoretic assumptions the greedy algorithm turns out to be the best one could hope for, although the same factor can also be achieved using linear programming.
We then solve the knapsack exactly on the new profit values p′ i. We now show that we do not loose much in rounding.
Theorem 4.2.1 The above mentioned algorithm achieves a 1 + approximation.
Proof: Let O denote the value of the optimal solution OP T on the original instance and O′ denote the value of OP T on new instances, i.e. O =
i∈OP T pi^ and^ O
i∈OP T p
′ i.
Similarly A and A′^ be the value of the solution obtained by the algorithm on original and new instances respectively.
Note that pi ≥ pmax K
pi × (^) pmaxK
. Hence
∑
i∈ALG
pi ≥
i∈ALG
pmax K
pi ×
K
pmax
Which is equivalent to A ≥ pmax K × A′. We solve the problem exactly on the new instances hence A′^ is the optimal value for p′ is. Hence A′^ ≥ O′. Combining the two inequalities we get A ≥ pmax K O′. Expanding O′^ we get the following
pmax K
O′^ =
pmax K
i∈OP T
pi ×
K
pmax
pmax K
i∈OP T
piK pmax
i∈OP T
pi − n
pmax K = O − pmax ≥ O(1 − )
Hence A ≥ O(1 − )
Note that the above mentioned algorithm takes O(pmaxn^2 ) time, hence the algorithm runs in time poly(n, (^1) ). Such algorithms belong to the so called F P T AS (Fully Polynomial Time Approx. Scheme) class. In general we have the following two relevant notions:
Definition 4.2.2 FPTAS (Fully Polynomial Time Approx. Scheme ): An algorithm which achieves an (1 + ) approximation in time poly(size, 1 /), for any > 0.
Definition 4.2.3 PTAS(Polynomial Time Approx. Scheme): Approximation scheme which achieves an (1 + ) approximation in time poly(size) , for any > 0.
Note that an F P T AS is the best algorithm possible for an N P -Hard problem. As mentioned before, knapsack also has a pseudo polytime algorithm. In fact, problems with an F P T AS often have pseudo polytime algorithms. The following theorem formalizes this.
Theorem 4.2.4 Suppose that an N P Hard optimization problem has an integral objective function, and the value of the function at its optimal solution is bounded by some polynomial in the size of the problem in unary, then an F P T AS for that problem implies an exact pseudo-polytime algorithm.
Proof: Suppose that B = poly(size), where size is the size of the problem in unary, upper bounds the optimal objective function value. Then we pick = (^21) B an run the F P T AS with this value. Then
ALG ≤ OP T
2 B
< OP T + 1
Since the objective function is integral, ALG = OP T , and we obtain an optimal solution. The algorithm runs in time poly(size).
References
[1] M. Andrews, L. Zhang. Hardness of the undirected edge-disjoint paths problem. In: Proceedings of the thirty-seventh annual ACM symposium on Theory of computing (STOC) (2005), pp: 276–
[2] C. Chekuri, S. Khanna. Edge disjoint paths revisited. In: Proceedings of the 14th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA) (2003), pp: 628–
[3] V. Guruswami, S. Khanna, R. Rajaraman, B. Shepherd, M. Yannakakis. Near-optimal hard- ness results and approximation algorithms for edge-disjoint paths and related problems. In: Proceedings of thirty-first annual ACM symposium on Theory of computing (STOC) (19993), pp: 19–
[4] J. Kleinberg. Approximation Algorithms for Disjoint Paths Problems. Ph.D Thesis, Dept. of EECS, MIT (1996).
