Stop Solving the Same Problem Twice

The plain-language idea

Imagine someone reads you a phone number, digit by digit, and you write it down. Later, when you need it again, would you call them back and ask them to repeat the whole thing? No — you'd look at what you already wrote. That's the entire idea behind dynamic programming: remember answers you've already worked out, so you never redo the same work twice.

A lot of problems, solved the first way that comes to mind, end up asking the exact same sub-question over and over without realizing it. Dynamic programming means noticing that, and writing the answer down the first time so every later ask is instant.

If the words "dynamic programming" sound like something only computer science majors understand, here's the honest truth: the name is intimidating, the idea underneath it is not. It's closer to "don't repeat yourself" than to anything mathematical. You already do this in daily life — that's the whole trick.

See it in a real thing: climbing a staircase

Say you're climbing a staircase, one or two steps at a time, and you want to know how many different ways there are to reach the top.

// How many ways can you climb `n` stairs, taking 1 or 2 steps at a time?
// Without memory, this recalculates the same smaller staircases again
// and again. With memory, we write each answer down once.
function waysToClimb(n, alreadySolved = {}) {
  if (n === 0) return 1; // standing at the top counts as 1 way
  if (n < 0) return 0; // overshot the stairs — not a valid way

  if (alreadySolved[n] !== undefined) {
    return alreadySolved[n]; // solved this one before — look it up
  }

  // otherwise, solve it: we either took a 1-step or a 2-step to get here
  const result = waysToClimb(n - 1, alreadySolved) + waysToClimb(n - 2, alreadySolved);

  alreadySolved[n] = result; // write it down before we need it again
  return result;
}

console.log(waysToClimb(5)); // 8 ways to climb a 5-step staircase

What people usually miss

Watch out

• "Isn't this recursion, with extra steps?" It's recursion plus a memory. Recursion alone can still repeat the same work many times over; dynamic programming is recursion that remembers what it already did.
• You don't need a formula to spot it. You don't need to recognize "this is shaped like the staircase problem." You need to notice you're asking the same smaller question more than once.
• The "aha" is in the writing-down, not the math. The staircase numbers themselves aren't the important part — the habit of caching an answer once and reusing it is.

The genealogy: recursion with a notebook

This builds directly on recursion from the JavaScript track — a function calling smaller versions of itself. Dynamic programming is that same idea with one addition: a notebook it checks before doing any piece of work twice.