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.
Build my CS 3100 study planWhat 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, not just 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, identify base cases — every time, in that order — 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.
- 6
Build the reps on a Fennie Daily Plan
Upload your CS 3100 syllabus and Fennie schedules spaced algorithm practice with DP given extra runway, paced to your exam dates, plus practice problems generated from the actual course materials. Free to start.
Start my CS 3100 plan free
How Fennie helps with CS 3100
Fennie's Daily Plans give CS 3100's design skills the spaced volume they require — dynamic programming practiced across weeks, not crammed — paced to exams. Chat works through why an algorithm applies and how you'd justify it, the design-and-argue skill exams actually grade, with practice problems that are deliberately unfamiliar, because that's the exam's whole design.
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.
Pass CS 3100 with a plan, not a cram
Upload your CS 3100 materials and Fennie generates a Daily Plan paced to your deadline — plus chat, flashcards, and quizzes built from the actual course content.
Get started freeMore UVA courses
CS 1110 — Introduction to Programming
CS 1110 is UVA's Python-based introduction to programming, assuming no prior experience — the entry point for prospective CS majors, minors, and a wide range of other students. It covers 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 — the mathematical foundation for algorithms and theory courses later in the major. 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 — building a working model of how computers actually execute code. Labs run alongside lecture, and it leads into CSO2.