Approximation Algorithms Overview: Computer Science Fundamentals

1. Introduction and Core Concepts

An approximation algorithms overview provides a foundational understanding of how computer scientists tackle optimization problems that are computationally intractable to solve exactly. For many NP-hard problems, finding the optimal solution requires exponential time, making exact algorithms impractical for large inputs. Approximation algorithms offer a principled alternative: they run in polynomial time and guarantee that the solution they produce is within a provable factor of the optimal solution.

This guarantee is what distinguishes approximation algorithms from heuristics. While a heuristic may perform well empirically, it offers no worst-case assurance about solution quality. An approximation algorithm, by contrast, comes with a mathematical proof that for every possible input, the ratio between the cost of the approximate solution and the cost of the optimal solution is bounded. This bound is known as the approximation ratio or approximation factor, typically denoted as ρ(n) or α, where the algorithm always produces a solution with cost at most α times the optimum for minimization problems, or at least 1/α times the optimum for maximization problems.

Understanding this paradigm is essential for modern complexity theory and practical system design. From scheduling jobs in cloud data centers to routing delivery vehicles and compressing data, many real-world challenges are modeled as NP-hard optimization problems. An approximation algorithms overview equips engineers with the tools to reason about trade-offs between computational efficiency and solution quality, enabling them to build scalable systems that deliver near-optimal performance with rigorous guarantees, even when perfect optimality is impossible.

Why Approximation Matters

The theory of NP-completeness tells us that if P ≠ NP, no polynomial-time algorithm can solve all instances of an NP-hard problem optimally. Rather than abandoning these problems, approximation theory asks a more nuanced question: how close can we get efficiently? This shift in perspective has led to a rich classification of problems based on their approximability. Some problems admit a Polynomial-Time Approximation Scheme (PTAS), where we can get arbitrarily close to optimal, while others are APX-hard, meaning there exists a constant threshold beyond which approximation is also NP-hard.

For practitioners, this matters because business constraints often tolerate near-optimal solutions. A logistics company saving 98% of the optimal routing cost in milliseconds is far more valuable than saving 100% in a week of computation. Approximation algorithms formalize this intuition and provide the analytical framework to make informed decisions about which algorithmic strategy to deploy under time and resource constraints.

Key Terminology

Several core concepts underpin the field. The approximation ratio is the worst-case ratio over all inputs. An algorithm has ratio α if for all instances I, cost(ALG(I)) ≤ α · cost(OPT(I)) for minimization. The performance guarantee may be absolute or asymptotic. PTAS is a family of algorithms that for any ε > 0 produces a (1+ε)-approximation in time polynomial in n (but possibly exponential in 1/ε). An FPTAS requires time polynomial in both n and 1/ε. APX is the class of problems with constant-factor approximations, and understanding these classes helps predict which problems are amenable to efficient near-optimal solutions.

2. How It Works

Approximation algorithms achieve their guarantees through a variety of design techniques, each exploiting structural properties of the underlying problem. Unlike a single unified method, the field is a toolkit of paradigms including greedy strategies, linear programming relaxation and rounding, primal-dual methods, dynamic programming with scaling, and randomized rounding. The common thread is that the algorithm first constructs a tractable relaxation or simplified view of the problem, solves it efficiently, and then converts that solution back into a feasible solution for the original problem while bounding the loss in quality.

One of the most powerful techniques is linear programming (LP) relaxation. Many combinatorial optimization problems can be formulated as integer linear programs (ILPs), which are NP-hard. By relaxing the integrality constraint — allowing variables to take fractional values between 0 and 1 — we obtain a polynomial-time solvable linear program. The optimal fractional value provides a lower bound (for minimization) on the true optimum. The algorithm then rounds the fractional solution to an integral one. The analysis shows that the rounding step increases the cost by at most a bounded factor, yielding the approximation ratio.

Greedy algorithms provide another simple yet surprisingly effective approach. For problems with submodular or matroid structure, a myopic choice that looks best locally can guarantee global approximation bounds. The classic example is the Set Cover problem, where repeatedly picking the set that covers the most uncovered elements yields an O(log n) approximation, which is asymptotically optimal under standard complexity assumptions. The analysis often uses charging arguments or potential functions to relate the greedy choices to the optimal solution.

The Role of Lower Bounds and Analysis

Proving an approximation ratio requires two ingredients: an upper bound on the algorithm's cost and a lower bound on the optimum. The lower bound is typically obtained from a relaxation, such as an LP optimum, a combinatorial bound like the size of a maximal matching, or the cost of a minimum spanning tree. The core of the analysis is to show that ALG ≤ α · LB and LB ≤ OPT, which together imply ALG ≤ α · OPT. This framework explains why understanding dual problems and weak duality is so crucial.

For minimization problems, we often prove that the algorithm never pays more than α times the lower bound. For maximization, we prove it always obtains at least 1/α of the upper bound. Tight examples are also important: constructing instances where the algorithm's ratio approaches α demonstrates that the analysis cannot be improved without changing the algorithm itself.

Deterministic vs. Randomized Guarantees

Approximation guarantees can be deterministic or expected. A deterministic algorithm always achieves the ratio. A randomized algorithm may achieve the ratio in expectation or with high probability. Techniques like randomized rounding — where a fractional LP variable x_i is rounded to 1 with probability x_i — often yield better ratios than deterministic rounding and can be derandomized using the method of conditional expectations if a deterministic guarantee is required.

3. Implementation

Implementing approximation algorithms requires careful attention to both correctness and the preservation of the theoretical guarantee. While the pseudocode may appear simple, subtle implementation details such as tie-breaking, data structure choice, and numerical precision can affect performance and even the approximation factor in practice. Below are four canonical implementations that illustrate different design paradigms.

The first example implements the classic 2-approximation for Minimum Vertex Cover. The algorithm finds a maximal matching and includes both endpoints of every matched edge. Any vertex cover must include at least one endpoint of each matched edge, so the optimal cover has size at least the number of matched edges, while our cover has exactly twice that size. This charging argument is simple to implement and runs in linear time.

# 2-Approximation for Minimum Vertex Cover via Maximal Matching
def approx_vertex_cover(graph):
    """
    graph: dict mapping vertex -> set of neighbors (undirected)
    Returns a vertex cover with |cover| <= 2 * |OPT|
    """
    cover = set()
    visited_edges = set()
    
    # Iterate over all vertices and edges
    for u in list(graph.keys()):
        for v in graph[u]:
            # Create canonical edge representation to avoid double counting
            edge = tuple(sorted((u, v)))
            if edge in visited_edges:
                continue
            # If neither endpoint is already in cover, add both
            if u not in cover and v not in cover:
                cover.add(u)
                cover.add(v)
                visited_edges.add(edge)
            # Mark edge as covered if at least one endpoint is in cover
            if u in cover or v in cover:
                visited_edges.add(edge)
    return cover

# Example usage:
# graph = {0: {1, 2}, 1: {0, 2}, 2: {0, 1, 3}, 3: {2}}
# print(approx_vertex_cover(graph))  # e.g., {0, 1, 2, 3} depending on order

The second example shows the greedy O(log n) approximation for Set Cover, which is widely used in resource allocation and data mining. At each step, it selects the set that covers the maximum number of currently uncovered elements. The implementation uses a priority structure and efficiently updates coverage counts.

# Greedy log(n)-Approximation for Set Cover
def approx_set_cover(universe, subsets):
    """
    universe: set of elements to cover
    subsets: dict mapping set_id -> set of elements
    Returns cover_ids with |cover| <= H_n * |OPT| where H_n is harmonic number
    """
    uncovered = set(universe)
    cover_ids = []
    # Work on a copy to avoid mutating input
    remaining = {sid: set(s) for sid, s in subsets.items()}
    
    while uncovered:
        # Greedily pick set covering most uncovered elements
        best_id = None
        best_cover = set()
        for sid, s in remaining.items():
            covered = s & uncovered  # intersection with uncovered
            if len(covered) > len(best_cover):
                best_cover = covered
                best_id = sid
        
        if best_id is None or len(best_cover) == 0:
            raise ValueError("Universe cannot be covered with given subsets")
        
        cover_ids.append(best_id)
        uncovered -= best_cover
        # Remove chosen set from consideration
        del remaining[best_id]
    
    return cover_ids

# Example:
# universe = {1, 2, 3, 4, 5}
# subsets = {'A': {1, 2, 3}, 'B': {2, 4}, 'C': {3, 4, 5}, 'D': {5}}
# print(approx_set_cover(universe, subsets))

The third implementation demonstrates a 2-approximation for the Metric Traveling Salesperson Problem (TSP) using a Minimum Spanning Tree (MST). When edge weights satisfy the triangle inequality, the cost of an MST is a lower bound on the optimal tour. Doubling the MST edges and shortcutting yields a tour at most twice the optimum. This is practical for logistics and network design.

# 2-Approximation for Metric TSP via MST (Prim's + DFS preorder)
import heapq

def approx_metric_tsp(dist_matrix):
    """
    dist_matrix: n x n matrix satisfying triangle inequality
    Returns tour list with cost <= 2 * OPT
    """
    n = len(dist_matrix)
    if n == 0:
        return []
    
    # Step 1: Build MST using Prim's algorithm O(n^2)
    in_mst = [False] * n
    parent = [-1] * n
    min_edge = [float('inf')] * n
    min_edge[0] = 0
    
    for _ in range(n):
        # Find minimum edge vertex not in MST
        u = -1
        best = float('inf')
        for i in range(n):
            if not in_mst[i] and min_edge[i] < best:
                best = min_edge[i]
                u = i
        in_mst[u] = True
        for v in range(n):
            if not in_mst[v] and dist_matrix[u][v] < min_edge[v]:
                min_edge[v] = dist_matrix[u][v]
                parent[v] = u
    
    # Build adjacency list for MST
    mst_adj = {i: [] for i in range(n)}
    for v in range(1, n):
        u = parent[v]
        if u != -1:
            mst_adj[u].append(v)
            mst_adj[v].append(u)
    
    # Step 2: DFS preorder walk to get tour (shortcutting)
    visited = set()
    tour = []
    stack = [0]
    while stack:
        u = stack.pop()
        if u in visited:
            continue
        visited.add(u)
        tour.append(u)
        # Push neighbors in reverse to maintain order
        for w in reversed(mst_adj[u]):
            if w not in visited:
                stack.append(w)
    
    tour.append(tour[0])  # return to start
    return tour

The final example illustrates the scaling technique used to obtain an FPTAS for the 0/1 Knapsack problem. By scaling profits down, we make the dynamic programming table polynomial in n and 1/ε, trading a small loss in optimality for exponential speedup. This technique is essential for resource-constrained scheduling.

# FPTAS for 0/1 Knapsack via Profit Scaling
def approx_knapsack_fptas(values, weights, capacity, epsilon):
    """
    values, weights: lists of length n
    epsilon: accuracy parameter 0 < epsilon < 1
    Returns selected indices with profit >= (1 - epsilon) * OPT
    """
    n = len(values)
    if n == 0:
        return []
    
    max_val = max(values)
    # Scaling factor K = epsilon * max_val / n
    K = (epsilon * max_val) / n
    if K == 0:
        K = 1
    
    # Scale values down: v'_i = floor(v_i / K)
    scaled_values = [int(v // K) for v in values]
    max_scaled = sum(scaled_values)
    
    # DP: dp[p] = min weight to achieve profit p
    INF = float('inf')
    dp = [INF] * (max_scaled + 1)
    dp[0] = 0
    # Keep track of choices for reconstruction
    keep = [[False] * (max_scaled + 1) for _ in range(n)]
    
    for i in range(n):
        # Iterate backwards to avoid reuse
        for p in range(max_scaled, scaled_values[i] - 1, -1):
            if dp[p - scaled_values[i]] + weights[i] < dp[p]:
                dp[p] = dp[p - scaled_values[i]] + weights[i]
                keep[i][p] = True
    
    # Find best feasible scaled profit
    best_p = 0
    for p in range(max_scaled + 1):
        if dp[p] <= capacity and p > best_p:
            best_p = p
    
    # Reconstruct solution
    selected = []
    cur_p = best_p
    for i in range(n - 1, -1, -1):
        if cur_p >= 0 and keep[i][cur_p]:
            selected.append(i)
            cur_p -= scaled_values[i]
    
    return list(reversed(selected))

4. Step-by-Step Example

To make the abstract concepts concrete, let us walk through the 2-approximation for Vertex Cover on a specific graph. Consider an undirected graph G with vertices {A, B, C, D, E} and edges: (A-B), (A-C), (B-C), (C-D), (D-E). The optimal vertex cover for this graph is {B, C, E} or {A, C, E} or {B, C, D}, all of size 3. We will trace how the maximal matching algorithm produces a cover of size at most 6, and in this case exactly 4, satisfying the 2-approximation guarantee.

Initialization begins with an empty cover C = {} and no matched edges. The algorithm iterates through edges in arbitrary order. Suppose the order is (A-B), (A-C), (B-C), (C-D), (D-E). For edge (A-B), neither A nor B is in C, so we add both A and B to C. Now C = {A, B} and the matching M = {(A-B)}. This step charges two vertices to one edge of the matching.

Next, edge (A-C) is examined. Since A is already in C, the edge is already covered, so we do nothing. Similarly, edge (B-C) is covered because B is in C. For edge (C-D), neither C nor D is in C (A and B are, but not C or D), so we add both C and D to C. Now C = {A, B, C, D} and M = {(A-B), (C-D)}. Finally, edge (D-E) is covered because D is in C, so no addition is needed. The algorithm terminates with cover {A, B, C, D} of size 4.

Verification of the Guarantee

We verify the ratio: |C| = 4, |OPT| = 3, so |C| / |OPT| = 1.33 ≤ 2. The analysis holds because M is a maximal matching of size 2. Any vertex cover must contain at least one endpoint from each edge in M, so |OPT| ≥ |M| = 2. Since |C| = 2|M| = 4, we have |C| = 2|M| ≤ 2|OPT|. Note that the algorithm's output depends on edge ordering; a different order like (B-C), (D-E), (A-B) would yield cover {B, C, D, E} also size 4. No ordering can produce a cover larger than 2|OPT|.

This example also illustrates tightness. Consider a complete bipartite graph K_{n,n} with n vertices on each side. The optimal cover is n (take one side), but the maximal matching algorithm could match all n pairs and return all 2n vertices, achieving exactly ratio 2. This shows the analysis is tight and the worst case is achievable.

Lessons from the Walkthrough

The walkthrough highlights three important lessons. First, the algorithm is extremely fast — O(V+E) — and trivial to implement compared to exponential exact search. Second, the guarantee is worst-case; typical instances often yield much better than factor 2. Third, the choice of lower bound (maximal matching size) is crucial for both the algorithm and its analysis. Without a strong lower bound, we cannot certify the quality of the solution. This pattern of pairing a constructive algorithm with a combinatorial lower bound recurs throughout approximation algorithm design.

5. Complexity Analysis

Approximation algorithms are evaluated along two dimensions: running time and approximation quality. Unlike exact algorithms where we only care about time, here we must trade off both. A good approximation algorithm runs in polynomial time — often low-degree polynomial — and achieves a small constant or logarithmic approximation factor. The complexity analysis must therefore cover both the computational complexity and the approximability.

Most classical approximation algorithms run in time comparable to their underlying building blocks. Greedy set cover runs in O(mn) where m is number of sets and n is universe size, or O( (sum |S_i|) log m ) with a priority queue. The MST-based TSP approximation runs in O(n^2) or O(m log n) depending on the MST implementation. LP-rounding algorithms are dominated by the time to solve the linear program, which is polynomial via interior-point methods, typically O(n^3.5) in practice, though often faster with commercial solvers. FPTAS algorithms have running time polynomial in both n and 1/ε, such as O(n^3 / ε) for knapsack.

Space complexity is usually modest. Greedy algorithms use O(n + m) additional space. DP-based FPTAS uses O(n * sum v'_i) which after scaling becomes O(n^2 / ε). LP-based methods require storing the constraint matrix, which can be large but is often sparse in combinatorial problems. Understanding these trade-offs is critical when deploying approximation at scale, for example in streaming or memory-constrained embedded systems.

The table reveals that better approximation ratios often come at higher computational cost. Christofides' algorithm improves TSP from 2 to 1.5 but requires computing a minimum weight perfect matching, increasing time to O(n^3). An FPTAS can achieve (1+ε) for any ε, but the running time blows up as ε approaches zero. This Pareto frontier between time and quality is a central theme in the field and must be navigated based on application requirements.

6. Variations and Optimizations

Beyond the basic constant-factor algorithms, the field has developed sophisticated hierarchies of approximation schemes that offer tunable trade-offs. The most important are PTAS, EPTAS, and FPTAS. A PTAS provides a (1+ε)-approximation for any fixed ε in time polynomial in n but possibly exponential in 1/ε, such as O(n^{1/ε}). An EPTAS improves this to f(1/ε) · poly(n), separating the dependence on ε. An FPTAS is the strongest, requiring time poly(n, 1/ε). Not all problems admit these schemes; for example, Knapsack has an FPTAS, Euclidean TSP has a PTAS, but general Metric TSP has no PTAS unless P=NP.

Another powerful optimization is the primal-dual method, which avoids solving the LP explicitly. Instead, it simultaneously constructs a feasible integral solution and a feasible dual solution, using complementary slackness conditions to bound the ratio. This yields faster, combinatorial algorithms with the same guarantees as LP rounding but without the overhead of an LP solver. The classic primal-dual 2-approximation for Vertex Cover and f-approximation for Set Cover (where f is maximum frequency) are examples that are widely used in practice due to their simplicity and speed.

Local search and hill-climbing provide another family of variations. Starting from an arbitrary feasible solution, the algorithm repeatedly makes small local improvements (e.g., swapping k elements) until a local optimum is reached. For problems like k-Median, Facility Location, and Max-Cut, local search with appropriate neighborhood size yields constant-factor approximations. The analysis uses exchange arguments to compare the local optimum to the global optimum. While often slower in worst-case theory, local search is highly practical and can be combined with other techniques.

Advanced Techniques

Semidefinite programming (SDP) relaxation lifts the power of LP by allowing variables to be vectors. The celebrated Goemans-Williamson 0.878-approximation for Max-Cut uses SDP rounding with a random hyperplane, beating the best possible LP-based ratio. Similarly, the Sherali-Adams and Lasserre hierarchies provide systematic ways to strengthen relaxations at the cost of increased size, yielding progressively better ratios for problems like Sparsest Cut and Unique Games.

Randomization and derandomization are also key optimizations. Many rounding schemes are randomized, giving expected guarantees that can be converted to high-probability guarantees via repetition or to deterministic guarantees via pessimistic estimators. For large-scale data, streaming and online variants of approximation algorithms process input with limited memory or without future knowledge, achieving competitive ratios that bound the cost relative to an offline optimum.

7. Real-World Applications

Approximation algorithms are not merely theoretical curiosities; they underpin critical infrastructure in web servers, databases, networks, and logistics. Their ability to deliver provably good solutions quickly makes them indispensable when exact optimization would cause unacceptable latency or cost.

In web servers and cloud computing, scheduling and load balancing are classic NP-hard problems. Assigning incoming requests to servers to minimize maximum load (Makespan Scheduling) is approximated by greedy list scheduling with ratio 2 - 1/m, and by more sophisticated algorithms achieving 4/3. Content delivery networks use Set Cover approximations to place replicas to cover user demand with minimum cost. Virtual machine placement, bin packing of containers, and cache replacement all rely on approximation guarantees to meet service-level agreements while maximizing utilization.

Database systems use approximation extensively for query optimization. Join ordering, which is NP-hard, is approximated via greedy or dynamic programming with pruning to find near-optimal execution plans in milliseconds. Sketching and synopsis structures like Count-Min and HyperLogLog provide (1+ε)-approximations for frequency estimation and distinct counting over massive streams, enabling real-time analytics on terabytes of data without exact computation. Even index selection can be modeled as a knapsack or set cover problem and approximated.

Network design is perhaps the most fertile ground. Designing minimum-cost networks to connect terminals (Steiner Tree), placing cell towers to cover regions (Set Cover), routing traffic to minimize congestion (Multicommodity Flow rounding), and clustering nodes for community detection (Correlation Clustering) all use approximation algorithms. The internet's own routing protocols use MST and shortest-path approximations to maintain connectivity efficiently.

Emerging applications include machine learning, where clustering problems like k-Means and k-Median are NP-hard and approximated via local search or coresets to handle billion-point datasets. Bioinformatics uses TSP and Set Cover approximations for genome assembly and primer selection. Even in finance, portfolio optimization with cardinality constraints is approximated to balance risk and return efficiently.

8. Comparison with Alternatives

When faced with an NP-hard optimization problem, engineers have several algorithmic families to choose from. Approximation algorithms are one point in a spectrum that includes exact exponential algorithms, heuristics, parameterized algorithms, and metaheuristics. Understanding the strengths and weaknesses of each is crucial for selecting the right tool.

Exact algorithms, such as branch-and-bound, integer programming with cutting planes, and exponential DP (e.g., Held-Karp for TSP in O(n^2 2^n)), guarantee optimality but scale poorly. They are suitable for small instances (n < 50) or when optimality is non-negotiable, such as in formal verification. Heuristics like greedy without guarantees, simulated annealing, or genetic algorithms are fast and often effective empirically but provide no worst-case bounds and can fail catastrophically on adversarial inputs. Approximation algorithms occupy the middle ground: they guarantee both polynomial time and a provable quality bound.

Parameterized complexity offers another alternative, where running time is exponential only in a small parameter k (e.g., solution size) but polynomial in n, such as O(2^k · poly(n)). This is excellent when k is small, but performs poorly when k is large. By contrast, approximation ratios are independent of parameter size. PTAS/FPTAS provide even stronger guarantees than constant-factor approximations but may have impractical running times for small ε due to large exponents or constants.

In practice, hybrid approaches are common. A system might run a fast 2-approximation to get an initial feasible solution and upper bound, then use that bound to prune an exact branch-and-bound search. Or it might use an approximation algorithm's LP relaxation to guide a heuristic's local search. The key insight is that approximation theory provides the rigorous foundation to understand what is achievable efficiently, informing the design of practical systems that blend multiple techniques.

9. Common Mistakes and Best Practices

Even experienced engineers can misuse approximation algorithms by misunderstanding their guarantees or misapplying them to unsuitable problems. One of the most common mistakes is confusing approximation ratio with empirical performance. An algorithm with ratio 2 does not mean it is always twice as bad as optimal; it means it is never worse than twice as bad, but often much better. Conversely, observing good performance on random test data does not prove a good worst-case ratio. Adversarial or structured instances may trigger the worst case in production.

Another pitfall is ignoring the problem's specific assumptions. The 2-approximation for TSP crucially requires the triangle inequality; applying it to general TSP with arbitrary edge weights provides no guarantee and can be arbitrarily bad. Similarly, the greedy Set Cover log n ratio assumes unit costs; with arbitrary costs, the ratio becomes log n but the implementation must use cost-effectiveness (coverage per cost) rather than raw coverage. Failing to verify that the input satisfies the preconditions voids the theoretical guarantee.

A third mistake is neglecting integrality gaps. The analysis of LP-rounding algorithms is limited by the gap between the LP optimum and the integer optimum. If the gap is large, no rounding of that LP can achieve a better ratio. Engineers sometimes attempt to improve the ratio by tweaking rounding without strengthening the relaxation, which is futile. Recognizing when a stronger formulation (e.g., adding valid inequalities or moving to SDP) is needed is essential.

Best Practices

• Prove or cite the ratio: Never claim an approximation factor without a proof or a reference to a peer-reviewed result. State whether the ratio is worst-case, expected, or with high probability.
• Benchmark against lower bounds: In production, compute both the approximate solution and a cheap lower bound (e.g., LP relaxation, MST cost, maximal matching size). The gap between them certifies the actual instance-specific quality, which is often far better than the worst-case bound.
• Choose the right scheme for the SLA: If the service requires 99% optimality, an FPTAS with ε = 0.01 may be appropriate despite higher cost. If 50% optimality is acceptable, a simple greedy 2-approximation is faster and simpler to maintain.
• Handle edge cases and numerical stability: Scaling techniques for FPTAS involve floating-point division; use careful rounding and avoid overflow. For graph algorithms, handle disconnected graphs, zero-weight edges, and large n with appropriate data structures like adjacency lists and heaps.
• Document assumptions: Clearly state that the algorithm assumes metric weights, unit costs, or other preconditions. Validate inputs early and fail fast if assumptions are violated.
• Combine with exact methods for small n: Use approximation for large instances and switch to exact solvers when n is small enough to solve optimally within latency budgets. This hybrid strategy maximizes quality across all input sizes.

Finally, remember that approximation algorithms are part of a larger system. Monitor their performance in production, log the achieved gaps, and use that data to refine model choices. A well-engineered system treats the approximation ratio as a contract, not just a theoretical curiosity.

10. Interview Questions

Interviewers frequently probe understanding of approximation algorithms to assess both theoretical depth and practical judgment. Below are common questions with guidance on what a strong answer should include.

Q1: What is the difference between an approximation algorithm and a heuristic? Give an example.

A strong answer defines both terms precisely: an approximation algorithm runs in polynomial time and has a proven worst-case bound on solution quality relative to OPT, while a heuristic is an empirical rule with no such guarantee. Example: For Vertex Cover, the maximal matching algorithm is a 2-approximation (provably at most twice optimal), whereas repeatedly picking the highest-degree vertex is a heuristic that can be arbitrarily bad — on a bipartite graph with one high-degree vertex connected to many leaves, it picks the high-degree vertex plus many leaves, while optimal picks all leaves. Emphasize that heuristics may outperform approximations empirically but cannot be trusted for worst-case inputs.

Q2: Explain why the greedy algorithm for Set Cover achieves an O(log n) approximation and why it cannot be improved significantly.

Answer should sketch the charging argument: each time the greedy picks a set covering k new elements, charge cost 1/k to each newly covered element. Show that any optimal solution must cover those elements, and use harmonic numbers to bound total charge by H_n · OPT. Mention that the analysis is tight — there are instances where greedy achieves Ω(log n) — and that Feige proved that no polynomial-time algorithm can achieve (1 - o(1)) ln n approximation unless P = NP, via reduction from Set Cover hardness. This demonstrates understanding of both upper and lower bounds.

Q3: You have a PTAS for a problem. Does that mean you can solve it optimally in polynomial time?

Answer: No. A PTAS gives (1+ε)-approximation for any fixed ε > 0, but the running time may be exponential in 1/ε, e.g., O(n^{1/ε}). To get exact optimality, you would need ε < 1/OPT, which could be exponentially small, making the running time exponential. Only an FPTAS with time poly(n, 1/ε) could potentially be pushed to optimality if OPT is polynomially bounded, but even then it would not be polynomial in general. Mention that existence of a PTAS does not imply P = NP; many NP-hard problems like Knapsack have an FPTAS yet remain NP-hard.

Q4: How would you design a 2-approximation for the Metric TSP? Why does it fail for general TSP?

Describe the MST-doubling algorithm: compute MST, double its edges to get Eulerian tour, shortcut to Hamiltonian cycle using triangle inequality to avoid revisiting vertices without increasing cost. Prove cost ≤ 2 · MST ≤ 2 · OPT, since MST ≤ OPT (removing one edge from OPT tour yields a spanning tree). For general TSP without triangle inequality, shortcutting can increase cost arbitrarily because direct edge may be much longer than indirect path, so no constant-factor approximation exists unless P = NP (reduction from Hamiltonian Cycle). This tests understanding of assumptions and lower bounds.

Q5: What is an integrality gap and why does it matter for LP-based approximations?

Define integrality gap as sup_I (OPT_integer(I) / OPT_LP(I)) for minimization. It measures the worst-case loss due to relaxation. If the gap is α, no rounding algorithm using that LP can achieve ratio better than α, because there exists an instance where the LP thinks the cost is 1 but any integer solution costs α. Example: Vertex Cover LP has gap 2 (on a complete graph, LP sets all x_v = 0.5, cost n/2, but integer optimum is n-1). Therefore, to beat factor 2, you need a stronger LP or a different technique. This shows insight into limitations of relaxations.