MIT 6.006: Introduction to Algorithms
6.006 is MIT's core algorithms class, covering sorting, hashing, trees, graph algorithms, shortest paths, and dynamic programming, with emphasis on both rigorous analysis and Python implementation. Its OpenCourseWare lectures are a global standard for learning algorithms and prepping technical interviews.
Fennie is independent and not affiliated with MIT. This is an unofficial study guide.
What makes it hard
Dynamic programming is the famous wall, and the psets require designing algorithms and arguing correctness, not just coding known ones. The exams test whether you can adapt techniques to novel problems under time pressure. Pattern-matching to memorized solutions reliably fails.
What you'll cover
- • Asymptotic analysis
- • Sorting and binary search trees
- • Hashing
- • Graph algorithms (BFS, DFS)
- • Shortest paths (Dijkstra, Bellman-Ford)
- • Dynamic programming
The 6.006 study guide
How to study for MIT 6.006, step by step.
- 1
Verify your discrete math is ready
6.006 leans on proofs, induction, and graph theory at the 6.042 level from week one. If correctness arguments feel foreign, spend a week reviewing before starting. It pays for itself many times over.
- 2
Run each unit as lecture, recitation problems, then pset
Watch or attend the lecture, work the recitation problems to convert understanding into skill, then take on the pset. Self-learners on OCW should follow the same three-stage rhythm rather than jumping straight to psets.
- 3
Give dynamic programming spaced, repeated attempts
DP is 6.006's famous wall, and it falls to repetition, not brilliance. Work DP problems across multiple sessions over weeks. Define the subproblem in words before writing any recurrence.
- 4
Check OCW solutions only after an honest attempt
The posted pset and exam solutions are a gift for self-learners when used correctly. Attempt each problem fully, then compare your reasoning against the solution and rework the misses days later.
Today
Today's 6.006 plan
What a Fennie Daily Plan looks like for 6.006. 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 6.006 hard?
Yes. It's the course where MIT students learn to design algorithms rather than use them, and dynamic programming humbles nearly everyone at first. Spaced practice on novel problems is the only reliable preparation.
How long does 6.006 take to self-study?
A serious OCW run takes most self-learners 3-4 months at 8-12 hours a week, including psets. It assumes prior programming and discrete math comfort.
What should I know before 6.006?
Python programming and discrete math at the level of 6.042: proofs, induction, basic graph theory. Going in without proof experience makes the correctness arguments much harder.
More MIT courses
6.100A: Introduction to Computer Science Programming in Python
6.100A, formerly 6.0001 (the number most search results still use), is MIT's half-semester introduction to programming in Python for students with little or no experience. The 6.0001 lectures on OpenCourseWare are among the most popular free programming courses anywhere.
6.046J: Design and Analysis of Algorithms
6.046J, renumbered 6.1220 in MIT's current catalog but still searched overwhelmingly by its old number, is the advanced algorithms course following 6.006: divide and conquer, randomized algorithms, amortization, network flow, approximation, and complexity. The OCW lectures are a staple for advanced self-study.
6.042J: Mathematics for Computer Science
6.042J, now numbered 6.1200J, is MIT's discrete math course for CS: proofs, induction, number theory, graph theory, counting, and discrete probability. Its OCW versions, with full lecture videos and the famous free textbook, make it one of the most-used discrete math resources in the world.
6.1010: Fundamentals of Programming
6.1010, formerly 6.009 (the number much of the internet still uses), is MIT's second programming course, where Python fluency from 6.100A gets turned into real software through substantial weekly labs: audio processing, image filters, graph search, interpreters. It's the bridge between knowing Python and engineering with it.