UCLA CS 180: Introduction to Algorithms and Complexity
CS 180 is UCLA's algorithms course: graph algorithms, greedy methods, divide and conquer, dynamic programming, network flow, and NP-completeness. It's the theory core of the upper division and the course most directly mirrored in technical interviews.
Fennie is independent and not affiliated with UCLA. This is an unofficial study guide.
What makes it hard
180 demands algorithm design plus correctness proofs and runtime analysis; partial understanding produces zero-credit attempts, and the dynamic-programming and reduction questions are the classic separators. The ten-week pace compresses notoriously hard material, so the gap between following lecture and inventing solutions on an exam closes fast.
What you'll cover
- • Graph algorithms and traversals
- • Greedy algorithms
- • Divide and conquer and recurrences
- • Dynamic programming
- • Network flow
- • NP-completeness and reductions
The CS 180 study guide
How to study for UCLA CS 180, step by step.
- 1
Refresh proof and graph basics before week one
180 assumes you can write induction and exchange arguments and reason about graphs immediately. On a ten-week quarter there's no warm-up period: arrive ready or spend midterm one catching up.
- 2
Attempt every problem solo before collaborating
The learning is in the struggle before the discussion. Give each homework problem a real solo attempt first; students who skip straight to group solutions consistently underperform on exams.
- 3
Treat dynamic programming as state, recurrence, base case
DP decides CS 180 grades. For every problem, write the subproblem definition explicitly before the recurrence; naming the state precisely is the hard part, and exams reward it.
- 4
Rehearse the standard NP reductions
Internalize the direction of a reduction and drill the canonical ones from lecture. Exam reductions are variations on patterns you can train deliberately rather than invent cold.
Today
Today's CS 180 plan
What a Fennie Daily Plan looks like for CS 180. 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 180 hard at UCLA?
It's one of the harder required CS courses because it fuses proof-writing with algorithm invention on a compressed quarter timeline. Students solid in discrete math and graphs adapt within weeks; rusty proof skills make the fast start rough.
What's the hardest part of CS 180?
Most students point to dynamic programming and NP-completeness reductions. Both are trainable: DP rewards defining the subproblem explicitly before anything else, and reductions follow patterns that practice makes recognizable.
How do I prepare for CS 180?
Be honest about your proof fluency and graph-algorithm recall before the quarter; 180 leans on both from problem one. Working a few induction and graph proofs beforehand removes most of the early shock on the ten-week schedule.
More UCLA courses
CS 31: Introduction to Computer Science I
CS 31 is UCLA's intro programming course, taught in C++, covering control flow, functions, arrays, pointers, and basic program design. It's the first required course for CS majors and a common choice for engineering and math students adding programming skills.
CS 32: Introduction to Computer Science II
CS 32 is UCLA's data structures course in C++, covering recursion, linked lists, stacks, queues, trees, hash tables, and algorithm analysis. Its multi-thousand-line projects, including the famous game-engine project, are a step change in scale from CS 31.
CS 33: Introduction to Computer Organization
CS 33 is UCLA's computer organization course, taking students below C into machine-level representation, x86-64 assembly, the memory hierarchy and caches, linking, and concurrency basics. It follows CS 32 and is where CS majors first see what their code becomes on real hardware.
CS 35L: Software Construction
CS 35L is UCLA's software-construction course, teaching the practical toolchain upper-division CS assumes: the Unix/Linux command line, shell scripting, Git, build systems, Python and scripting, and a collaborative software project. Long associated with Professor Eggert, it's the course that turns students into functional engineers.