Basic Techniques of Approximation Algorithms

Approximation algorithms use several fundamental techniques to achieve near-optimal

solutions efficiently. These techniques depend on the problem structure and are designed to
ensure both computational efficiency and a provable approximation ratio.

1. Greedy Algorithms

Description:

 Build the solution step-by-step by making the locally optimal choice at each step.
 Greedy choices aim to maximize or minimize a certain criterion in each iteration.

Example: Vertex Cover

 For a graph G=(V,E)G = (V, E)G=(V,E), repeatedly pick an edge and add both its
endpoints to the vertex cover until all edges are covered.
 Approximation Ratio: 222.

2. Local Search

Description:

 Start with a feasible solution and iteratively improve it by making local changes (e.g.,
swapping or replacing elements).
 The process stops when no further improvements are possible.

Example: k-Center Problem

 Place kkk centers to minimize the maximum distance between any point and its
nearest center.
 Iteratively adjust center locations to reduce the maximum distance.

3. Rounding

Description:

 Solve a relaxed version of the problem (e.g., using Linear Programming or

Semidefinite Programming).
 Round the fractional solution to an integral one while maintaining feasibility and
bounding the approximation ratio.

Example: Set Cover

  Relax the integer linear program for the problem into a linear program.
 Solve the LP and round the fractional solution to obtain a valid cover.
 Approximation Ratio: O(log⁡n)O(\log n)O(logn), where nnn is the number of elements.

4. Primal-Dual Method

Description:

 Simultaneously construct a primal feasible solution (for the original problem) and a
dual feasible solution (for its dual).
 Use the relationship between the primal and dual solutions to bound the
approximation ratio.

Example: Facility Location Problem

 Approximation algorithms for this problem use primal-dual methods to determine

facility placements and allocations.

5. Dynamic Programming with Restrictions

Description:

 Modify dynamic programming to use limited resources (e.g., time or space).

 Often involves relaxing constraints or discretizing problem variables.

Example: Knapsack Problem

 Relax the weights or profits to fit into a polynomial-time DP table.

 Approximation Ratio: 1−ϵ1 - \epsilon1−ϵ, where ϵ\epsilonϵ depends on the granularity
of the discretization.

6. Divide and Conquer

Description:

 Divide the problem into smaller subproblems, solve each approximately, and combine
the solutions.

Example: Euclidean TSP

 Divide the points into regions, solve locally using a heuristic, and combine the paths.
7. Randomized Algorithms

Description:

 Use randomness to make decisions during the algorithm.

 Guarantees are often in expectation or with high probability.

Example: MAX-CUT Problem

 Assign nodes to two sets randomly and adjust iteratively to maximize the number of
edges crossing the cut.
 Approximation Ratio: 0.8780.8780.878 (using semidefinite programming).

8. Reduction to a Simpler Problem

Description:

 Reduce the original problem to a simpler problem that is easier to approximate.

 Solve the simpler problem and map the solution back to the original problem.

Example: Metric TSP

 Reduce TSP to the Minimum Spanning Tree (MST) problem and construct an
approximate solution using the MST.

9. Dual Fitting

Description:

 Solve the dual of the relaxed problem and use it to guide the construction of a feasible
primal solution.
 The approximation ratio is derived from the relationship between the primal and dual
solutions.

Example: Set Cover

 Use dual fitting to derive a logarithmic approximation bound.

10. Iterative Refinement

Description:

 Start with a coarse solution and iteratively refine it to improve the objective value.
Example: Scheduling Problems

 Start with a naive assignment of jobs and iteratively balance loads between machines.

Summary

Approximation
Technique Key Idea Example
Ratio
Greedy Make locally optimal choices. Vertex Cover 2
Improve iteratively via local k-Center
Local Search 2
changes. Problem
Relax constraints and round O(log⁡n)O(\log
Rounding Set Cover
fractional solutions. n)O(logn)
Primal-Dual Use primal and dual Facility
1.61
Method relationships to bound solutions. Location
Dynamic Simplify DP to run in limited Knapsack
1−ϵ1 - \epsilon1−ϵ
Programming resources. Problem
Divide and Solve subproblems and combine
Euclidean TSP 2
Conquer solutions.
Randomized Use randomness to make
MAX-CUT 0.878
Algorithms decisions.
Reduction Reduce to simpler problems. Metric TSP 2
Fit primal solutions using the O(log⁡n)O(\log
Dual Fitting Set Cover
dual. n)O(logn)
Iterative Start coarse and refine Scheduling Depends on the
Refinement iteratively. Problems problem

These techniques provide the foundation for designing efficient approximation algorithms
tailored to specific NP-hard problems.