Udemy
    •  
    •  
    •  
    •  
    •  
    •  
    •  
    •  
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
Recurofy: Learn Recursion and Dynamic Programming
Rating: 4.8 out of 5(29 ratings)
1,073 students

Recurofy: Learn Recursion and Dynamic Programming

Specialized course to teach you how to solve recursive and dynamic programming problems in coding interviews
Created byJoseph Patchen, Amazon Software Engineer
Last updated 3/2025
English

What you'll learn

  • Have an intuitive framework that can be used to solve recursive problems you have not seen before
  • Understand two main ways of thinking about recursive problems: self-similar or decision trees
  • Know when and how to apply dynamic programming optimization to recursive algorithms
  • Solve recursive and dynamic programming problems in coding interviews

Coding Exercises

This course includes our updated coding exercises so you can practice your skills as you learn.

See a demo
Image of coding exercise example

Course content

5 sections • 22 lectures • 2h 8m total length

  • Self-Similarity3:15

    Explore self-similarity and fractals like the Sierpinski triangle, and learn recursive algorithms that solve problems from coin change to grid paths, tree structures, and chess, culminating in dynamic programming optimization.

  • Recursion2:15

    Explore recursion through a simple print cat function that calls itself. Learn the three main parts: parameters, base case, and recurrence relation that prevent infinite recursion.

  • Intro to Recursive Algorithms5:00

    Explore the Fibonacci sequence as a first recursive algorithm, including recurrence, base cases, and how recursion forms a call tree, with a preview of dynamic programming to optimize.

  • Fibonacci Number
  • Decision Trees13:39

    Map all valid ways to divide colored blocks into groups with no duplicates using decision trees. See how recursion creates a variable-depth tree and leads to dynamic programming insights.

  • Big O Space and Time Complexity of Recursive Algorithms8:24

    Learn to calculate the worst-case space and time complexity of recursive algorithms using max depth, max branching factor, and the call stack, plus formulas O(B^D * t) and O(d * S).

  • Two Types of Recursive Algorithms1:25

    Explore two main types of recursive algorithms, including self-similar and divide algorithms, and build a solid algorithm foundation before tackling dynamic programming.

Requirements

  • Basic programming experience
  • Basic Python knowledge: In this course, we'll use Python to illustrate various algorithms. You don't need extensive Python knowledge to follow along; the basics can be picked up as you watch. For instance, when I began creating this course, I wasn't highly proficient in Python, but I became productive quickly. This is because the level of Python expertise required to solve problems related to data structures and algorithms is quite minimal.
  • Basic understanding of data structures and algorithms: Essentially, you should be somewhat familiar with solving basic non-recursive problems involving data structures and algorithms. Additionally, having a basic grasp of space and time complexity is necessary.

Description

When I was preparing for coding interviews a while back, I found recursion and dynamic programming to be among the hardest topics covered. It felt like it took me weeks to get good at solving these types of problems. After I finished preparing for interviews, I thought there must be an easier way for someone to learn how to solve these types of problems, so they can learn this much quicker. After solving more than 100 recursive and dynamic programming problems, I created a problem-solving framework that you can use to solve these types of problems.


This course teaches you this framework by first splitting up all recursive algorithms into two types: self-similar algorithms and decision tree algorithms. Self-similar algorithms solve problems where there is an easy to see self-similar relationship with the problem itself we are solving for, and decision tree algorithms solve problems by 'trying' every possible decision sequence in a system. We will spend time building a strong foundation on how to solve problems with recursion (even problems that are typically referred to as dynamic programming problems), and then, with a strong foundation, we will learn how to improve our recursive algorithms with dynamic programming.


Prerequisites:

  1. The course uses Python, requiring only a basic understanding of the language.

  2. A basic understanding of non-recursive space and time complexity.

  3. A basic understanding of non-recursive data structures and algorithms, such as hash tables and tree structures, is required.

Who this course is for:

  • Software engineers preparing for technical interviews, particularly those that include recursive and dynamic programming problems, such as those conducted by companies like MAANG.

Report abuse