Recursion, Backtracking and Dynamic Programming in Python

Recursion, Backtracking and Dynamic Programming in Python, available at $124.99, has an average rating of 4.55, with 142 lectures, 37 quizzes, based on 895 reviews, and has 11418 subscribers.

You will learn about Understanding recursion Understand backtracking Understand dynamic programming Understand divide and conquer methods Implement 15+ algorithmic problems from scratch Improve your problem solving skills and become a stronger developer This course is ideal for individuals who are This course is meant for newbies who are not familiar with algorithmic problems in the main or students looking for some refresher or Anyone preparing for programming interviews or interested in improving their problem solving skills It is particularly useful for This course is meant for newbies who are not familiar with algorithmic problems in the main or students looking for some refresher or Anyone preparing for programming interviews or interested in improving their problem solving skills.

Enroll now: Recursion, Backtracking and Dynamic Programming in Python

Summary

Title: Recursion, Backtracking and Dynamic Programming in Python

Price: $124.99

Average Rating: 4.55

Number of Lectures: 142

Number of Quizzes: 37

Number of Published Lectures: 135

Number of Published Quizzes: 35

Number of Curriculum Items: 179

Number of Published Curriculum Objects: 170

Original Price: $199.99

Quality Status: approved

Status: Live

What You Will Learn

Understanding recursion

Understand backtracking

Understand dynamic programming

Understand divide and conquer methods

Implement 15+ algorithmic problems from scratch

Improve your problem solving skills and become a stronger developer

Who Should Attend

This course is meant for newbies who are not familiar with algorithmic problems in the main or students looking for some refresher

Anyone preparing for programming interviews or interested in improving their problem solving skills

Target Audiences

This course is meant for newbies who are not familiar with algorithmic problems in the main or students looking for some refresher

Anyone preparing for programming interviews or interested in improving their problem solving skills

This course is about the fundamental concepts of algorithmic problems focusing on recursion, backtracking, dynamic programmingand divide and conquerapproaches. As far as I am concerned, these techniques are very important nowadays, algorithms can be used (and have several applications) in several fields from software engineering to investment banking or R&D.

Section 1 – RECURSION

what are recursion and recursive methods

stack memory and heap memory overview

what is stack overflow?

Fibonacci numbers

factorial function

tower of Hanoi problem

Section 2 – SEARCH ALGORITHMS

linear search approach

binary search algorithm

Section 3 – SELECTION ALGORITHMS

what are selection algorithms?

Hoare’s algorithm

how to find the k-th order statistics in O(N) linear running time?

quickselect algorithm

median of medians algorithm

the secretary problem

Section 4 – BIT MANIPULATION PROBLEMS

binary numbers

logical operators and shift operators

checking even and odd numbers

bit length problem

Russian peasant multiplication

Section 5 – BACKTRACKING

what is backtracking?

n-queens problem

Hamiltonian cycle problem

coloring problem

knight’s tour problem

maze problem

Sudoku problem

Section 6 – DYNAMIC PROGRAMMING

what is dynamic programming?

knapsack problem

rod cutting problem

subset sum problem

Kadane’s algorithm

longest common subsequence (LCS) problem

Section 7 – OPTIMAL PACKING 

what is optimal packing?

bin packing problem

Section 8 – DIVIDE AND CONQUER APPROACHES

what is the divide and conquer approach?

dynamic programming and divide and conquer method

how to achieve sorting in O(NlogN) with merge sort?

the closest pair of points problem

Section 9 – Substring Search Algorithms

substring searchalgorithms

brute-force substring search

Z substring search algorithm

Rabin-Karp algorithm and hashing

Knuth-Morris-Pratt (KMP) substring search algorithm

Section 10 – COMMON INTERVIEW QUESTIONS

top interview questions (Google, Facebook and Amazon)

anagram problem

palindrome problem

integer reversion problem

dutch national flag problem

trapping rain water problem

Section 11 – Algorithms Analysis

how to measure the running time of algorithms

running time analysis with big O(ordo), big Ω (omega) and big θ(theta)notations

complexity classes

polynomial (P) and non-deterministic polynomial (NP) algorithms

In each section we will talk about the theoretical background for all of these algorithms then we are going to implement these problems together from scratch in Python.

Thanks for joining the course, let’s get started!

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 – Hoares 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: Knights tour introduction

Lecture 18: Knights tour implementation I

Lecture 19: Knights 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

Instructors

Holczer Balazs
Software Engineer

Rating Distribution

1 stars: 17 votes

2 stars: 20 votes

3 stars: 82 votes

4 stars: 289 votes

5 stars: 487 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!