UVA CS 3100: Data Structures and Algorithms 2
CS 3100 is the algorithms half of UVA's DSA pair: graph algorithms, greedy methods, divide and conquer, and dynamic programming, with runtime analysis and correctness reasoning throughout. It draws directly on both CS 2100's structures and CS 2120's proof techniques.
Fennie is independent and not affiliated with University of Virginia. This is an unofficial study guide.
What makes it hard
Dynamic programming is the famous wall: there's no template that survives contact with a new problem, and exams present problems you haven't seen. The course grades algorithm design and justification as much as implementation. Students who got through 2100 on coding ability alone discover the 2120 proof skills they cut corners on are now load-bearing.
What you'll cover
- • Graph representations and traversals
- • Shortest paths and minimum spanning trees
- • Greedy algorithms
- • Divide and conquer
- • Dynamic programming
- • Runtime analysis and correctness arguments
The CS 3100 study guide
How to study for UVA CS 3100, step by step.
- 1
Rehab CS 2120 skills before they're load-bearing
Induction and precise argument are how CS 3100 expects you to justify algorithms. If your proof skills were scraped-by, spend the first week rebuilding them; the course assumes them silently.
- 2
Learn algorithms as design ideas, not procedures
For each algorithm, know the problem it solves, the insight that makes it work, and why it's correct. Exams present unfamiliar problems; only the insight transfers.
- 3
Give dynamic programming honest volume
DP is learned by solving many problems badly first. Define the subproblem in words, write the recurrence, and identify base cases, in that order every time, across enough problems that the pattern-finding becomes the skill.
- 4
Practice problems you haven't seen weekly
The exam's whole design is novel problems. Pull practice from past exams and other courses' problem sets, attempt them cold under time, and audit what hint you needed.
- 5
Trace the classic algorithms on real examples
Run Dijkstra, MST algorithms, and graph traversals by hand on small graphs until the mechanics are automatic. Trace questions are reliable exam points and the foundation for the design questions.
Today
Today's CS 3100 plan
What a Fennie Daily Plan looks like for CS 3100. Yours is built from your own syllabus and adapts every day to your deadlines and progress.
First plan free, no card required. Fennie is independent and unaffiliated with your school.
FAQ
Is CS 3100 at UVA hard?
It's where the major shifts from writing code to designing and justifying algorithms. Dynamic programming on unfamiliar problems is the famous exam wall, and the proof skills from CS 2120 are suddenly load-bearing. Students who practice novel problems weekly handle it; memorizers of specific algorithms don't.
How do I get good at dynamic programming?
Volume with structure: for every problem, define the subproblem in words first, then the recurrence, then base cases, in that order, every time. Expect to solve many problems badly before the pattern-recognition arrives; that struggle is the mechanism, not a sign it isn't working.
What should I take before CS 3100?
CS 2100 and CS 2120, and both genuinely matter. The data structures are assumed as vocabulary, and the discrete math is how you'll be asked to argue correctness and runtime. Weakness in either one surfaces within the first few weeks.
More UVA courses
CS 1110: Introduction to Programming
CS 1110 is UVA's Python-based introduction to programming, assuming no prior experience. It is the entry point for prospective CS majors, minors, and a wide range of other students, covering variables, control flow, functions, lists and dictionaries, file handling, and basic objects, with weekly labs and programming assignments.
CS 2100: Data Structures and Algorithms 1
CS 2100 is the first course of UVA's renumbered CS core: data structures and algorithms in Java, covering lists, stacks, queues, trees, hash tables, and runtime analysis, with required labs alongside lecture. It replaced the old CS 2110/2150 path and is the gateway the rest of the major builds on.
CS 2120: Discrete Mathematics and Theory 1
CS 2120 is the discrete math course of UVA's CS core: logic, proofs, sets, functions, induction, and basic graph and number theory. It is the mathematical foundation for algorithms and theory courses later in the major, and it's most students' first proof-based course.
CS 2130: Computer Systems and Organization 1
CS 2130 takes UVA CS students below the languages they know: binary representation, gates and circuits, assembly, and C programming with pointers and memory. The goal is a working model of how computers actually execute code. Labs run alongside lecture, and it leads into CSO2.