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.

Build my CS 180 study plan

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.
5
Build solving-under-pressure with Fennie
Upload the CS 180 syllabus and Fennie's Daily Plans schedule steady problem and proof practice paced to the quarter's midterms, generating fresh DP and reduction problems from your actual course materials when the sets run out. Free to start.
Start my CS 180 plan free

How Fennie helps with CS 180

Daily Plans pace CS 180 with steady problem volume across the ten-week quarter, because algorithm design is a trained skill and cramming theory fails. Use Fennie's chat to pressure-test your proofs — explain why your greedy argument holds and let the gaps surface — and generate fresh DP and reduction practice when the problem sets run dry.

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.

Pass CS 180 with a plan, not a cram

Upload your CS 180 materials and Fennie generates a Daily Plan paced to your deadline — plus chat, flashcards, and quizzes built from the actual course content.

Get started free

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.