Back to Blog
Dynamic ProgrammingMedium

Dynamic Programming for Beginners: Memoization vs Tabulation

Understand the fundamentals of dynamic programming with clear examples and when to use memoization vs bottom-up approaches.

January 5, 2025
15 min read
DPAlgorithmsOptimization

Dynamic Programming for Beginners: Memoization vs Tabulation


Dynamic Programming (DP) is a powerful technique for solving optimization problems by breaking them into smaller subproblems.


The Core Idea


DP solves problems by:

  • Breaking them into overlapping subproblems
  • Storing results to avoid recomputation
  • Building up solutions from smaller solutions

  • Memoization (Top-Down)


    Memoization uses recursion with caching:


    def fib_memo(n, memo={}):
        if n in memo:
            return memo[n]
        if n <= 2:
            return 1
        memo[n] = fib_memo(n - 1, memo) + fib_memo(n - 2, memo)
        return memo[n]

    Pros:

  • Intuitive (follows problem structure)
  • Only computes needed subproblems

  • Cons:

  • Recursion overhead
  • Stack overflow risk for deep recursion

  • Tabulation (Bottom-Up)


    Tabulation builds solutions iteratively:


    def fib_tab(n):
        if n <= 2:
            return 1
        dp = [0] * (n + 1)
        dp[1] = dp[2] = 1
        
        for i in range(3, n + 1):
            dp[i] = dp[i - 1] + dp[i - 2]
        
        return dp[n]

    Pros:

  • No recursion overhead
  • Better space optimization possible

  • Cons:

  • May compute unnecessary subproblems
  • Less intuitive for some problems

  • When to Use Which?


  • Memoization: When you don't need all subproblems
  • Tabulation: When you need all subproblems or want to optimize space

  • Classic DP Problems


  • Fibonacci: Basic DP introduction
  • Climbing Stairs: Similar to Fibonacci
  • Coin Change: Optimization problem
  • Longest Common Subsequence: 2D DP

  • Start with these to build your DP intuition!


    Related Articles

    Binary Search
    A comprehensive guide to binary search algorithms, covering standard search, rotated arrays, and finding boundaries.
    Computer Science
    A beginner-friendly guide to analyzing algorithm efficiency and understanding Big O, Omega, and Theta notation.
    Backtracking
    Deep dive into backtracking algorithms with examples including permutations, combinations, and constraint satisfaction problems.