Recursion, Backtracking and Dynamic Programming in Python

Course Curriculum

Chapter 1: Introduction

Lecture 1: Introduction

Chapter 2: Environment Setup

Lecture 1: Installing Python

Lecture 2: Installing PyCharm

Chapter 3: Recursion

Lecture 1: What are stack and heap memory?

Lecture 2: Stack memory and heap memory simulation

Lecture 3: What is recursion (recursive function call)?

Lecture 4: Head and tail recursion implementation

Lecture 5: Recursion and stack memory (stack overflow)

Lecture 6: Recursion optimization in Python

Lecture 7: Factorial problem – with head recursion

Lecture 8: Factorial problem – visualizing the stack

Lecture 9: Transforming a head recursion into a tail recursion

Lecture 10: Fibonacci numbers problem – with head recursion

Lecture 11: Fibonacci numbers – visualizing the stack memory

Lecture 12: Fibonacci-numbers with tail recursion solution

Lecture 13: Reverse string solution

Lecture 14: Towers of Hanoi introduction

Lecture 15: Towers of Hanoi implementation

Lecture 16: Towers of Hanoi – visualizing the stack

Lecture 17: Solution – solving recursion with iteration

Lecture 18: What is the Euclidean algorithm?

Lecture 19: Euclidean algorithm implementation

Lecture 20: Recursion and iteration revisited

Chapter 4: Search Algorithms

Lecture 1: What is linear search?

Lecture 2: Linear search implementation

Lecture 3: Solution – linear search with recursion

Lecture 4: What is binary (logarithmic) search?

Lecture 5: Binary search implementation

Chapter 5: Selection Algorithms

Lecture 1: Selection algorithms introduction

Lecture 2: Quickselect introduction – Hoare's algorithm

Lecture 3: Quickselect visualization

Lecture 4: Quickselect implementation

Lecture 5: Solution – sorting with selection

Lecture 6: What is the problem with pivots?

Lecture 7: Advanced selection – median of medians, introselect

Lecture 8: Median of medians algorithm implementation

Lecture 9: Introselect algorithm – power of combining algorithms

Lecture 10: Online selection – the secretary problem

Chapter 6: Bit Manipulation Problems

Lecture 1: Binary representation of numbers

Lecture 2: Logical operators

Lecture 3: Binary shift operators

Lecture 4: Finding the bit length of an integer

Lecture 5: Checking even and odd numbers

Lecture 6: Russian peasant problem

Lecture 7: Russian peasant multiplication with recursion solution

Chapter 7: Backtracking

Lecture 1: What is backtracking?

Lecture 2: Brute-force search and backtracking

Lecture 3: N-queens problem introduction

Lecture 4: What is the search tree?

Lecture 5: N-queens problem implementation I

Lecture 6: N-queens problem implementation II

Lecture 7: N-queens problem and stack memory visualization

Lecture 8: How to earn $1 million with N-queens problem?

Lecture 9: Hamiltonian paths (and cycles) introduction

Lecture 10: Hamiltonian cycle illustration

Lecture 11: Hamiltonian path implementation I

Lecture 12: Hamiltonian path implementation II

Lecture 13: Solution – finding Hamiltonian cycle

Lecture 14: Coloring problem introduction

Lecture 15: Coloring problem visualization

Lecture 16: Coloring problem implementation

Lecture 17: Knight's tour introduction

Lecture 18: Knight's tour implementation I

Lecture 19: Knight's tour implementation II

Lecture 20: Maze problem introduction

Lecture 21: Maze problem implementation

Lecture 22: Maze problem and stack memory visualization

Lecture 23: Sudoku introduction

Lecture 24: Sudoku implementation I

Lecture 25: Sudoku implementation II

Lecture 26: Sudoku implementation III

Lecture 27: What is the problem with backtracking?

Chapter 8: Dynamic Programming

Lecture 1: Dynamic programming introduction