The document discusses approximation algorithms for NP-complete problems. It introduces the idea of finding near-optimal solutions in polynomial time for problems where optimal solutions cannot be found efficiently. It provides examples of the vertex cover problem and set cover problem, describing greedy approximation algorithms that provide performance guarantees for finding near-optimal solutions for these problems. The document also discusses some open questions around whether these approximation ratios can be improved.

1. Approximation
Algorithms
presented by
Nicolas Bettenburg
1

2. Many problems with practical significance
are NP-complete.
Unlikely to find a polynomial-time
solution algorithm (nobody knows).
2

3. Work around NP
completeness
• Small Inputs: stay with exponential
algorithm!
• Often special cases are solvable in
polynomial time.
• Find a near-optimal solution in
polynomial time that is good enough.
3

4. Approximation Algorithms
• For a lot of practical applications near-optimal
solutions are perfectly acceptable.
• Algorithms that return near-optimal solutions for a
problem are called approximation algorithms.
• Want to study polynomial time approximation
algorithms for NP-complete problems.
4

5. What is ‘’good enough’’?
For an approximation algorithm A
of input of size n
the cost of solution produced by A is C
Approximation Ratio of A is p(n)
C C∗
max ,
∗ C
≤ p(n)
C
5

6. An approximation algorithm with ratio p(n)
is called a p(n)-approximation algorithm.
6

7. List of 21 Problems
that are NP-complete
Richard Karp, 1972
.
.
.
• CLIQUE
• SET PACKING
• VERTEX COVER
• SET COVERING
• FEEDBACK NODE SET
• FEEDBACK ARC SET
• KNAPSACK
• PARTITION
• MAX-CUT
.
.
.
7

8. Vertex Cover Problem
8

9. Vertex Cover
a subset U of all vertices V, such
that every edge in E is covered.
b c d
a e f g
Covered Edge
an edge e = (vi, vj) is covered if ei or ej is chosen.
9

10. Minimum Vertex Cover
Problem
Input: a Graph G = (V, E)
Output: the smallest subset U ⊆ V
such that ∀e = (vi , vj ) ∈ E, i = j
vi ∈ U or vj ∈ U
10

11. b c d
a e f g
Input: G
11

12. b c d
a e f g
12

13. b c d
a e f g
13

14. b c d
a e f g
Output: C = {b, d, e}
14

15. Greedy-Vertex-Cover(G)
1 C = {}
2 do chose v in V with max deg
3 C = C + {v}
4 remove v and every edge
5 adjacent to v
6 until all edges covered
7 return C
15

16. b c d
a e f g
16

17. b c d
a e f g
17

18. b c d
a e f g
3 possible choices here
determines the outcome
18

19. b c d
a e f g
19

20. b c d
a e f g
20

21. b c d
a e f g
Goodness of solution depends
on the (random) choices made.
21

22. Approx-Vertex-Cover(G)
1 C = {}
2 E’ = E[G]
3 while E’ != {}
4 do let (u,v) be some e in E’
5 C = C + {u, v}
6 remove from E’ every edge
7 incident to either u or v
8 end do
9 end while
10 return C
22

23. Approx-Vertex-Cover(G)
1 C = {}
2 E’ = E[G]
3 while E’ != {}
4 do let (u,v) be some e in E’
5 C = C + {u, v}
6 remove from E’ every edge
7 incident to either u or v
8 end do
9 end while
10 return C O(|V | + |E|)
23

24. b c d
a e f g
C = {}
E = {(a-b), (b-c), (c-e), (c-d),(e-f),(e-d), (f-d), (d-g)}
24

25. b c d
a e f g
C = {}
E = {(a-b), (b-c), (c-e), (c-d),(e-f),(e-d), (f-d), (d-g)}
25

26. b c d
a e f g
C = {b, c}
E = {(e-f),(e-d), (f-d), (d-g)}
26

27. b c d
a e f g
C = {b, c}
E = {(e-f),(e-d), (f-d), (d-g)}
27

28. b c d
a e f g
C = {b, c, e, f}
E = {(d-g)}
28

29. b c d
a e f g
C = {b, c, e, f}
E = {(d-g)}
29

30. b c d
a e f g
C = {b, c, e, f, d, g}
E = {}
30

31. C = {b, c, e, f, d, g}
|C| = 6 = 2 · 3 ≤ 2 · |C ∗ |
the algorithm found a 2-approximation.
b c d
a e f g
31

32. Approx-Vertex-Cover(G)
1 C = {}
2 E’ = E[G]
3 while E’ != {}
4 do let (u,v) be some e in E’
5 C = C + {u, v}
6 remove from E’ every edge
7 incident to either u or v
8 end do
9 end while
10 return C
C is a vertex cover of G
Proof:
The algorithm loops until every edge in E’ = E[G] has been
covered (removed) by some vertex in C.
32

33. Approx-Vertex-Cover(G)
1 C = {}
2 E’ = E[G]
3 while E’ != {}
4 do let (u,v) be some e in E’
5 C = C + {u, v}
6 remove from E’ every edge
7 incident to either u or v
8 end do
9 end while
10 return C
C is at most 2 times C*
Proof:
Let A be the set of edges picked by algorithm step 4. C*
must include at least one endpoint of each edge in set A. No
two edges share an endpoint, since all adjacent edges are
deleted after picking in line 6. Thus no two edges in A are
covered by the same vertex in C*.
|C ∗ | ≥ |A|
33

34. Approx-Vertex-Cover(G)
1 C = {}
2 E’ = E[G]
3 while E’ != {}
4 do let (u,v) be some e in E’
5 C = C + {u, v}
6 remove from E’ every edge
7 incident to either u or v
8 end do
9 end while
10 return C
C is at most 2 times C*
Proof:
Each execution of line 4 picks an edge for which neither of
the endpoints are in C already.
|C| = 2 · |A|
|C ∗ | ≥ |A|
34

35. Can we do better?
35

36. Maximal Matching
b c d
a e f g
Input: a graph G=(V, E)
Output: a maximal subset E’ of E, such that
no two edges share a common
vertex.
36

37. The approximation algorithm
produces a maximal matching
37

38. Alternative Formulation
of Vertex Cover
b c d
a e f g
Input: a graph G=(V, E)
Output: the endpoints of a maximal matching
38

39. In Bipartite Graphs:
Maximal Matching = Minimal Vertex Cover
Stated as König’s Theorem in 1914,
proven in 1916.
39

40. Complete bipartite Graph with n vertices
40

41. Is a tight example, has maximal matching of n.
41

42. Hence |C| = 2n. So 2 is a tight bound!
42

43. No better algorithm than the 2-approximation
algorithm for computing the vertex cover
in polynomial time is known so far.
43

44. A parallel algorithm to compute the 2-approximate
minimum vertex cover in O(log3|E|)
with O(|V|+|E|) processors was discovered in 2006.
44

45. Set Cover Problem
45

46. The Set Cover Problem
Input: a finite Set X
Output: a family F of subsets of X,
such that every element of X
belongs to at least one subset in F: X = ∪S∈F S
46

47. Set X
S1
S4 S2
S6
S3 S5
Subsets S1, S2, S3, S4, S5, S6
47

48. Set X
S1
S4 S2
S6
S3 S5
Minimum-Size Cover: S3, S4, S5
48

49. Greedy-Set-Cover(G)
1 U = X
2 C = {}
3 while U != {} do
4 select an S in F
5 that maximizes |S ∩U|
6 U = U-S
7 C = C ∪{S}
8 end while
9 return C
O(|X| · |F |)
49

50. Greedy-Set-Cover is an
(ln |X|+1)-approximation algorithm.
50

51. Can we do better?
51

52. Open research
question
52

53. Discussion
53