Skip to main content
Fennie
HomeGet Started
CU Boulder
Computer Science
4 credits

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 — sitting at the top of the CS core and assuming 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.

Build my CSCI 3104 study plan

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. 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. 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. 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. 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. 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.

  6. 6

    Give the paradigms spaced practice with Fennie

    Upload your CSCI 3104 syllabus and Fennie's Daily Plan spaces problem practice per paradigm with DP given double runway, plus quizzes from your actual course content ahead of each exam. Free to start.

    Start my CSCI 3104 plan free

How Fennie helps with CSCI 3104

Fennie's Daily Plans space CSCI 3104's paradigms across the semester with dynamic programming given the double runway it needs, paced to exam dates. Chat works through how to spot the subproblem structure in a new scenario — the creative step exams test — until paradigm-matching becomes a skill instead of luck.

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.

Pass CSCI 3104 with a plan, not a cram

Upload your CSCI 3104 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 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 — built around a famous sequence of hands-on labs including the bomb lab, where you defuse a binary by reading its assembly.