CU Boulder CSCI 3104: Algorithms
CSCI 3104 is CU Boulder's algorithms course: design paradigms like divide-and-conquer, greedy, and dynamic programming, plus graph algorithms and complexity analysis. It sits at the top of the CS core and assumes both CSCI 2270's structures and CSCI 2824's proofs.
Fennie is independent and not affiliated with University of Colorado Boulder. This is an unofficial study guide.
What makes it hard
Dynamic programming is the famous wall: identifying subproblems is a creative act no template covers, and exam problems are deliberately unfamiliar. The course also demands proving algorithms correct and analyzing their runtime, so students weak in either data structures or discrete math get hit from both directions at once.
What you'll cover
- • Asymptotic analysis and recurrences
- • Divide-and-conquer
- • Greedy algorithms
- • Dynamic programming
- • Graph algorithms (shortest paths, spanning trees)
- • Intro to complexity and NP-completeness
The CSCI 3104 study guide
How to study for CU Boulder CSCI 3104, step by step.
- 1
Audit your prerequisites in week one
CSCI 3104 assumes 2270's structures and 2824's induction fluently; DP correctness arguments are induction in disguise. Rehab whichever is shaky immediately; the course won't slow down.
- 2
Solve unfamiliar problems, not just assigned ones
Exams present problems you haven't seen, testing whether you can match a paradigm to a new scenario. Practice from other textbooks and past exams so novelty itself stops being the obstacle.
- 3
Build dynamic programming up from the recursion
For every DP problem, write the plain recursive solution first, then identify the repeated subproblems. Students who memorize famous DP tables can't generate new ones; students who practice the recursion-first method can.
- 4
Practice the justification, not just the algorithm
Half the credit is arguing correctness and runtime. For each problem you solve, write the why (exchange arguments for greedy, induction for DP), because that's the part exams actually grade.
- 5
Run graph algorithms by hand
Trace Dijkstra, BFS/DFS, and MST algorithms on small graphs until the mechanics are automatic. Trace questions are reliable exam points and a foundation for the design questions.
Today
Today's CSCI 3104 plan
What a Fennie Daily Plan looks like for CSCI 3104. 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 CSCI 3104 at CU Boulder hard?
It's the intellectual peak of the Boulder CS core: exams pose unfamiliar problems and grade the correctness and runtime arguments, not just the algorithm. Students who practice novel problems and write justifications handle it; pattern memorizers struggle.
How do I get good at dynamic programming for CSCI 3104?
Always start from the plain recursive solution and look for repeated subproblems; that's the generative method. Memorizing famous DP solutions teaches recognition, but exams test production on problems you haven't seen.
What should I review before taking CSCI 3104?
CSCI 2270's structures (especially trees and graphs) and CSCI 2824's proof techniques, induction above all. The course assumes both fluently, and DP correctness arguments are essentially induction proofs.
More CU Boulder courses
CSCI 1300: Computer Science 1: Starting Computing
CSCI 1300 is CU Boulder's first programming course for CS majors and minors, taught in C++ (variables, control flow, functions, arrays, and intro object concepts), with weekly recitations and a project-heavy assignment load. It's the gate into the rest of the CSCI core.
CSCI 2270: Computer Science 2: Data Structures
CSCI 2270 is the second course in CU Boulder's CS core: linked lists, stacks, queues, binary search trees, hash tables, and graphs, implemented in C++ with pointers and manual memory management. It's the course Boulder CS students most often name as the major's first real filter.
CSCI 2824: Discrete Structures
CSCI 2824 is CU Boulder's discrete math course for CS majors: logic, proof techniques, set theory, induction, counting, and graph theory. It's most students' first encounter with writing mathematical proofs, and it underpins the algorithms course that follows.
CSCI 2400: Computer Systems
CSCI 2400 takes CU Boulder CS students below the language level: data representation, C and assembly, the memory hierarchy, and how programs actually execute. It's built around a famous sequence of hands-on labs including the bomb lab, where you defuse a binary by reading its assembly.