The ultimate guide to dynamic programming interviews. Developed by FAANG engineers, it equips you with strategic DP skills, practice with real-world questions, and patterns for efficient solutions.

Some of the toughest questions in technical interviews require dynamic programming solutions. Dynamic programming (DP) is an advanced optimization technique applied to recursive solutions. However, DP is not a one-size-fits-all technique, and it requires practice to develop the ability to identify the underlying DP patterns. With a strategic approach, coding interview prep for DP problems shouldn’t take more than a few weeks.

This course starts with an introduction to DP and thoroughly discusses five DP patterns. You’ll learn to apply each pattern to several related problems, with a visual representation of the working of the pattern, and learn to appreciate the advantages of DP solutions over naive solutions.

After completing this course, you will have the skills you need to unlock even the most challenging questions, grok the coding interview, and level up your career with confidence.

This course is also available in C++, JavaScript, and Python—with more coming soon!

Grokking Dynamic Programming Interview

# Statement
Given an array `nums` of positive numbers, start from the first index and reach the last index with the minimum number of jumps, where a number at an index represents the maximum jump from that index.

For example, if the value at the current index is $3$, then a maximum of $3$ and a minimum of a $1$ step jump can be taken in the direction of the last index of the array. You cannot move in the opposite direction, that is, away from the last index.

Let's say you have an array of $[2, 3, 1, 5, 7]$, starting from the $0^{th}$ index. It requires only two jumps to reach the last index. The first jump will be from the $0^{th}$ index to the $1^{st}$ index, i.e., only a one-step jump, and the next jump will be from the $1^{st}$ index to the $4^{th}$ index, i.e., a three-step jump.

**Constraints:**
- $1 \leq$ `nums.length` $\leq 10^3$
- $0 \leq$ `nums[i]` $\leq 10^3$
- It's guaranteed that you can reach the last index of `nums`.

# Examples

Let's solve the Minimum Jumps to Reach the End problem using Dynamic Programming.

Getting Started

0/1 Knapsack

Unbounded Knapsack

Recursive Numbers

Longest Common Substring

Palindromic Subsequence

Conclusion

Minimum Jumps to Reach the End