Cs 6515 - Final Exam Take-Home | Full Questions And Worked Out Solutions | 2026 Updated | Original Practice Questions

1|Page



CS 6515 - FINAL EXAM TAKE-HOME |
FULL QUESTIONS AND WORKED OUT
SOLUTIONS | 2026 UPDATED | ORIGINAL
PRACTICE QUESTIONS
INTRODUCTION
CS 6515, Introduction to Graduate Algorithms, is a graduate-level course in algorithm design
and analysis at Georgia Tech. The current Georgia Tech course description identifies major areas
including dynamic programming, divide and conquer, FFT, graph and flow algorithms, RSA,
linear programming, and NP-completeness. Students are expected to apply algorithmic
techniques, analyze correctness and complexity, and reason about computational tradeoffs rather
than simply memorize definitions.

This practice examination is designed for students preparing for a comprehensive CS 6515
assessment. The questions emphasize difficult, application-oriented situations involving
recurrence analysis, optimization, graph structure, network flows, randomized algorithms,
cryptographic reasoning, linear programming, and computational complexity. Each question
provides four choices and a detailed rationale explaining the underlying algorithmic reasoning.
The problems are intentionally varied so that students practice recognizing which technique
applies to a new problem, identifying incorrect approaches, and evaluating asymptotic
performance. Because individual Georgia Tech sections may modify schedules, assessments, or
emphasis, this bank should be treated as a comprehensive study resource rather than an official
Georgia Tech examination or answer key.

CONTENT AREA OVERVIEW
Content Area Questions Key Topics Weight
Recurrences, merge sort, selection, FFT, master-
Divide & Conquer 1–12 12%
style analysis
Optimal substructure, memoization, shortest
Dynamic Programming 13–28 16%
paths, sequence problems
BFS, DFS, shortest paths, MST, DAGs,
Graph Algorithms 29–42 14%
connectivity
Residual networks, augmenting paths, cuts,
Max-Flow & Min-Cut 43–53 11%
reductions
Randomized Algorithms Probability, expected runtime, randomized
54–63 10%
& RSA analysis, modular arithmetic
Linear Programming 64–73 LP formulation, duality, feasibility, optimization 10%

,2|Page


Content Area Questions Key Topics Weight
P, NP, reductions, SAT, CLIQUE, vertex cover,
NP-Completeness 74–88 15%
hardness
Integrated Algorithm Algorithm selection, correctness, complexity,
89–100 12%
Analysis tradeoffs



QUESTIONS 1–100
DIVIDE AND CONQUER
Q1:

An algorithm divides an input of size nn into three subproblems of size n/2n/2, performs
Θ(n)\Theta(n) additional work, and then combines their results. Which asymptotic running time
best describes the algorithm?

A) Θ(n)\Theta(n)

B) Θ(nlog⁡23)\Theta(n^{\log_2 3})

C) Θ(nlog⁡n)\Theta(n\log n)

D) Θ(2n)\Theta(2^n)

Rationale: The recurrence is T(n)=3T(n/2)+Θ(n)T(n)=3T(n/2)+\Theta(n). The recursive
contribution has exponent log⁡23≈1.585\log_2 3\approx1.585, which dominates the linear
combine work. Thus T(n)=Θ(nlog⁡23)T(n)=\Theta(n^{\log_2 3}). A is too small, C does not
account for the three-way recursion, and D is exponentially larger than the actual recurrence.

Q2:

A divide-and-conquer algorithm satisfies T(n)=2T(n/2)+Θ(nlog⁡n)T(n)=2T(n/2)+\Theta(n\log
n). Which complexity is most appropriate?

A) Θ(n)\Theta(n)

B) Θ(nlog⁡n)\Theta(n\log n)

C) Θ(nlog⁡2n)\Theta(n\log^2 n)

D) Θ(n2)\Theta(n^2)

,3|Page


Rationale: The recursion tree has log⁡n\log n levels. At each level, the combined nonrecursive
work is Θ(nlog⁡n)\Theta(n\log n), giving Θ(nlog⁡2n)\Theta(n\log^2 n) overall. A and B
underestimate the accumulated work, while D is unnecessarily large.

Q3:

A sorting algorithm recursively sorts two halves and performs linear work to merge them. An
implementation reduces the merge operation from Θ(n)\Theta(n) to Θ(n/log⁡n)\Theta(n/\log n)
while preserving correctness. What asymptotic improvement results?

A) From Θ(nlog⁡n)\Theta(n\log n) to Θ(n)\Theta(n)

B) From Θ(nlog⁡n)\Theta(n\log n) to Θ(nlog⁡log⁡n)\Theta(n\log\log n)

C) From Θ(nlog⁡n)\Theta(n\log n) to Θ(log⁡n)\Theta(\log n)

D) No asymptotic improvement

Rationale: The recurrence becomes T(n)=2T(n/2)+Θ(n/log⁡n)T(n)=2T(n/2)+\Theta(n/\log n).
Summing the per-level work gives approximately
n∑i=1log⁡n1/i=Θ(nlog⁡log⁡n)n\sum_{i=1}^{\log n}1/i=\Theta(n\log\log n). Thus B is the
correct asymptotic improvement.

Q4:

Suppose a recursive algorithm performs four subproblems of size n/2n/2 and Θ(n2)\Theta(n^2)
nonrecursive work. Which term determines its asymptotic complexity?

A) The leaves only, giving Θ(n)\Theta(n)

B) The recursive calls, giving Θ(n2)\Theta(n^2), independent of the combine work

C) Both the recursive and nonrecursive terms contribute at the same order, resulting in
Θ(n2log⁡n)\Theta(n^2\log n)

D) The algorithm is exponential

Rationale: The recurrence is T(n)=4T(n/2)+Θ(n2)T(n)=4T(n/2)+\Theta(n^2). Since
nlog⁡24=n2n^{\log_2 4}=n^2, the recurrence is at the balanced boundary. Each recursion
level contributes Θ(n2)\Theta(n^2), across Θ(log⁡n)\Theta(\log n) levels, giving
Θ(n2log⁡n)\Theta(n^2\log n).

Q5:

, 4|Page


An algorithm recursively processes an array by solving one problem of size n−1n-1 and
performing constant work. Which implementation technique could reduce the risk of stack
overflow without changing the asymptotic running time?

A) FFT

B) Iterative reformulation

C) Randomized pivoting

D) Minimum spanning tree construction

Rationale: The recurrence is Θ(n)\Theta(n), but recursion depth is also Θ(n)\Theta(n). An
iterative implementation can preserve the Θ(n)\Theta(n) running time while avoiding deep
recursion. The other techniques address unrelated algorithmic problems.

Q6:

A selection algorithm partitions an array around a pivot and guarantees that at least 30% of
elements are eliminated from further consideration at each recursive step. What is the strongest
conclusion?

A) Worst-case time is necessarily Θ(log⁡n)\Theta(\log n)

B) Worst-case time is Θ(n2)\Theta(n^2)

C) If partitioning costs linear time, the recurrence yields linear worst-case time

D) The algorithm must be randomized

Rationale: If every recursive call reduces the problem to at most 70% of its original size, then
T(n)=T(0.7n)+Θ(n)T(n)=T(0.7n)+\Theta(n). The geometric sum of partition costs is
Θ(n)\Theta(n). Therefore C is correct.

Q7:

A divide-and-conquer algorithm makes two recursive calls on 3n/43n/4 elements and performs
Θ(n)\Theta(n) combine work. Which statement is most accurate?

A) It is necessarily quadratic.

B) Its complexity is Θ(nlog⁡4/32)\Theta(n^{\log_{4/3}2})

C) It is necessarily linear.

D) It is exponential in nn.