Introduction

Recall we were talking about approximation algorithms for optimization problems associated with a given `NP`-complete problem.
On Monday, we gave an algorithm that computes a vertex cover which is within a factor of 2 of the optimally sized vertex cover for a graph.
We had earlier shown that the problem: Does a graph have a vertex cover of size `k`? is NP-complete.
Before we continue with other approximation algorithms let's briefly review some defintions...
We say an algorithm for a problem has an approximation ratio of `r(n)`, if for any input of size `n`, the cost `C` of the solution produced by the algorithm is within a factor of `r(n)` of the cost `C^star` of the optimal solution. That is, `max(C/C^star, C^star/C) le r(n)`.
We call an algorithm that achieves an `r(n)`-approximation ratio an `r(n)`-approximation algorithm.
Some `NP`-complete problems have a trade-off between the approximation ratio and the run time.
An approximation scheme for an optimization problem is an algorithm that takes both an instance of the problem as well as a constant `epsilon` and then runs a `(1 + epsilon)`-approximation algorithm on the instance.
If for any `epsilon`, the approximation scheme runs in `p`-time, then it is called a polynomial time approximation scheme.
We say that an approximation scheme is a fully `p`-time approximation scheme if it is an approximation scheme and its run time is `p`-time in both `1/epsilon` and the instance size `n`. For example, the scheme might have a running time of `O((1/epsilon)^2n^3)`.

Approximating the Traveling Salesman Problem

The optimization problem associated with TSP is to find a tour of least cost.
Here is a 2-approximation algorithm for this problem when the triangle inequality holds on the distances between cities.

APPROX-TSP-TOUR(G, c)
1. Select a vertex r to be a root vertex
2. Compute the minimal spanning tree for G from root r using Prim's algorithm
3. Let L be the list of vertices visited in a pre-order tree walk of T
4. return the Hamiltonian cycle H that visits the vertices in order L.

Subroutines used by our algorithm

Recall in a pre-order traversal of a graph starting from some node, we visit the node and then each child we have not yet visited.
Recall Prims algorithm contructs a minimal spanning tree from a tree so far, denoted `A`, which at the start of the algorithm is the empty tree.
We maintain a priority queue of all the vertices not in A.
The priority, `v.key`, for a vertex `v` in the queue is the least weight of any edge connecting `v` with `A`. If no such edge exists than it is `infty`.
Let `v.pi` be the parent of `v` in the tree. Rather than explicitly have an `A` we use this parent structure to get the tree when the algorithm terminates.

Here is the pseudo-code:

MST-PRIM(G, w, r) // r is a starting node to grow the tree from
01 for each u in G.V
02    u.key = infty
03    u.pi = NIL
04 r.key = 0
05 r.pi = 0;
06 Q = MAKE-QUEUE(G.V) //will have all vertices
07 while Q != 0
08     u = EXTRACT-MIN(Q)
09     for each v in G.adj[u]
10        if v in Q  and u.key + w(u, v) < v.key
11            v.pi = u
12            v.key = u.key + w(u,v) //call appropriate DECREASE-KEY

Analysis of APPROX-TSP-TOUR

Theorem. APPROX-TSP-TOUR is a p-time 2-approximation algorithm for TSP with triangle-inequality holding on the cost function.

Proof. The minimal spanning tree algorithm runs in time `O(|V|^2)`. The remaining step take at most `O(|G|)` time.

Let `H^star` denote the optimal tour of the vertices. Since we can obtain a spanning tree from any tour by deleting an edge, we have `c(T) le c(H^star)` where `T` is our minimal spanning tree. A full walk `F` of `T` lists the vertices when they are first visited and also whenever they are returned to after a visit to a subtree. So `c(F) = 2c(T) le 2c(H^star)`. A full walk is typically not a tour since it lists some vertices twice.

On the other hand, the `H` returned by the algorithm is a tour and satisfies `c(H) le c(F)`, since it is obtained by deleting vertices from the full walk and since the triangle inequality holds. We are using the triangle inequality as if we have a sequence `a b c` in the full walk and delete `b`, in our tour we want that the cost does not rise.

In-Class Exercise

Consider the weighted graph on four vertices `\{ 1,2,3,4 \}` where the edge weight is computed as the absolute value of the difference of the vertices. So edge `{1,3}` have weight 2.
Verify that the edges in this graph obey the triangle inequality.
Show how the algorithm just given would compute a tour.
Post your answer to In-Class Exercise Thread.

General TSP

Theorem. If `P ne NP`, then for any constant `d ge 1`, there is no `p`-time approximation algorithm with approximation ratio `d` for general TSP.

Proof. Suppose that for some number `d ge 1`, there was an approximation algorithm `A` for general TSP with the given approximation ratio. Without loss of generality, we can assume `d` is an integer. We will then show how to use `A` to solve instances of HAM-CYCLE. Since HAM-CYCLE is NP- complete, this will imply the result...

Proof of Inapproximability of General TSP cont'd

Let `G = (V, E)` be an instance of the HAM-CYCLE problem. Let `G'= (V, E')` be the complete graph on `V`. Assign a cost to each edge in `E'` as follows:
`c(u,v) = {(1,mbox(if ){u,v} in E),(d cdot |V| + 1,mbox(otherwise.)):}`

This instance `(G', c)` of the TSP optimization problem can be created in p-time in the HAM-CYCLE instance length. If the original graph has a Hamiltonian cycle, then there is a tour following its edges of cost `|V|`. On the other hand, if no such tour exists, then a tour uses at least one edge not in `E`, so has cost `(d cdot |V| +1) + (|V| - 1) > d cdot |V|`. Since our approximation algorithm needs to find a tour within a factor of `d` of the smallest one, if there is a Hamiltonian cycle in `G` when we run `A` the tour output will have cost `le d cdot|V|`. On the other hand, if the graph G does not have a hamiltonian cycle our algorithm on this instance will return a value `> d cdot|V|`.

Approximation Algorithms