Dynamic Programming (DP) is a powerful technique used to solve complex problems by breaking them down into simpler subproblems. In this blog, we delve into various DP patterns including 1D DP, 2D grids, subsets, strings, and more. We'll explore real-world applications and provide detailed examples to help you understand and implement these patterns in your coding projects. Join us as we unravel the intricacies of DP and enhance your problem-solving skills.

Dynamic Programming All Patterns

Pattern 1: 1D Dynamic Programming

1D Dynamic Programming is often the starting point for beginners. Here, you deal with problems where the solution can be represented as a linear progression, often involving sequences or simple state transitions.

• Climbing Stairs: A classic problem that demonstrates how each step depends on the previous one or two steps.

  • URL: Climbing Stairs (LeetCode)

• Frog Jump: Similar to climbing stairs but with varying jump lengths.

  • URL: Frog Jump (LeetCode)

• Frog Jump with K: Extends the basic Frog Jump problem to allow jumps of up to K steps.

  • URL: Frog Jump with K Steps (GeeksforGeeks)

• Maximum Sum of Non-Adjacent Elements: Find the maximum sum possible by selecting elements that are not adjacent in an array.

  • URL: House Robber (LeetCode)

• House Robber: A variant of the above problem where you're a robber trying to maximize your loot without robbing two adjacent houses.

  • URL: House Robber (LeetCode)

• Ninja's Training 2: A more complex problem where each action affects future decisions.

  • URL: Ninja's Training (Coding Ninjas)

Key Takeaway: These problems teach you to think in terms of cumulative solutions, where the current state is determined by previous decisions.

Pattern 2: Dynamic Programming on Grids / 2D

• Unique Paths: Calculate the number of unique paths from the top-left to the bottom-right of a grid.

  • URL: Unique Paths (LeetCode)

• Minimum Path Sum in Grid: Find the minimum path sum from the top-left to the bottom-right of a grid.

  • URL: Minimum Path Sum (LeetCode)

• Triangle (Fixed Starting Point and Variable Ending Point): Find the minimum path sum from the top to bottom of a triangle.

  • URL: Triangle (LeetCode)

• Cherry Pickup 2: A more complex problem involving two players collecting maximum cherries on a grid.

  • URL: Cherry Pickup 2 (LeetCode)

Key Takeaway: These problems extend the 1D dynamic programming approach to a 2D grid, requiring you to consider both row and column transitions.

Pattern 3: Dynamic Programming on Subsets / Subsequences

• Subset Sum Equals to Target: Determine if there exists a subset with a sum equal to the target.

  • URL: Subset Sum (GeeksforGeeks)

• Partition Equals Subset Sum: Partition an array into two subsets with equal sums.

  • URL: Partition Equal Subset Sum (LeetCode)

• Partition a Subset into 2 Subset with Minimum Absolute Sum Difference: Minimize the difference between the sums of two subsets.

  • URL: Partition a Subset into 2 Subset with Minimum Absolute Sum Difference (LeetCode)

• Count Subsequences with Sum K: Count the number of subsequences with a sum equal to K.

  • URL: Count Subsequences with Sum K (GeeksforGeeks)

• Count Partitions with Given Difference: Count the number of ways to partition an array into subsets with a given difference.

  • URL: Count Partitions with Given Difference (GeeksforGeeks)

Key Takeaway: These problems involve finding specific subsets or subsequences that satisfy given conditions, often requiring a bitmask or combinatorial approach.

Pattern 4: Dynamic Programming on Strings

• Print Length of Longest Common Subsequence: Calculate the length of the longest common subsequence between two strings.

  • URL: Longest Common Subsequence (LeetCode)

• Print Longest Common Subsequence: Print the longest common subsequence itself.

  • URL: Longest Common Subsequence (LeetCode)

• Longest Palindromic Subsequence: Find the longest subsequence that reads the same forward and backward.

  • URL: Longest Palindromic Subsequence (LeetCode)

• Minimum Insertion to Make String Palindrome: Find the minimum number of insertions needed to make a string palindrome.

  • URL: Minimum Insertion to Make String Palindrome (LeetCode)

• Minimum Insertions/Deletions to Convert String A -> B: Find the minimum number of insertions and deletions required to transform one string into another.

  • URL: Minimum Insertions/Deletions to Convert String A -> B (GeeksforGeeks)

Key Takeaway: These problems focus on string manipulations, often involving comparisons and transformations between multiple strings.

Pattern 5: Dynamic Programming on Stocks

• Best Time to Buy and Sell Stock (Buy Once and Sell Once): Maximize profit by buying and selling a stock once.

  • URL: Best Time to Buy and Sell Stock (LeetCode)

• Best Time to Buy and Sell Stock 2 (Unlimited Time Buy & Sell): Maximize profit by buying and selling stocks multiple times.

  • URL: Best Time to Buy and Sell Stock 2 (LeetCode)

• Best Time to Buy and Sell Stock 3 (At Max 2 Times Buy & Sell): Maximize profit by buying and selling stocks up to two times.

  • URL: Best Time to Buy and Sell Stock 3 (LeetCode)

• Best Time to Buy and Sell Stock 4 (K times Buy & Sell): Maximize profit by buying and selling stocks up to K times.

  • URL: Best Time to Buy and Sell Stock 4 (LeetCode)

• Best Time to Buy and Sell Stock 5 (Buy & Sell with Cooldown): Maximize profit with a cooldown period between transactions.

  • URL: Best Time to Buy and Sell Stock 5 (LeetCode)

Key Takeaway: These problems involve optimizing stock transactions to maximize profit under various constraints.

Pattern 6: Dynamic Programming on Longest Increasing Subsequences (LIS)

• Print Length of Longest Increasing Subsequence: Calculate the length of the longest increasing subsequence in an array.

  • URL: Longest Increasing Subsequence (LeetCode)

• Print Longest Increasing Subsequence: Print the longest increasing subsequence itself.

  • URL: Longest Increasing Subsequence (LeetCode)

• Longest Divisible Subset: Find the largest subset of numbers where each pair is divisible.

  • URL: Longest Divisible Subset (LeetCode)

• Longest String Chain: Find the longest chain of strings where each string is formed by adding one character to the previous string.

  • URL: Longest String Chain (LeetCode)

• Longest Bitonic Subsequence: Find the longest subsequence that first increases and then decreases.

  • URL: Longest Bitonic Subsequence (GeeksforGeeks)

Key Takeaway: These problems focus on finding and manipulating sequences where elements

follow a specific order.

Pattern 7: Hardest Dynamic Programming on Partition

• Matrix Chain Multiplication: Determine the most efficient way to multiply a series of matrices.

  • URL: Matrix Chain Multiplication (GeeksforGeeks)

• Minimum Cost to Cut the Stick: Find the minimum cost to cut a stick at specified positions.

  • URL: Minimum Cost to Cut the Stick (LeetCode)

• Burst Balloons: Maximize the coins obtained by bursting balloons in a certain order.

  • URL: Burst Balloons (LeetCode)

• Evaluate Boolean: Evaluate the number of ways to parenthesize a boolean expression.

  • URL: Evaluate Boolean (GeeksforGeeks)

• Palindrome Partitioning 2: Minimize the cuts needed to partition a string into palindromes.

  • URL: Palindrome Partitioning 2 (LeetCode)

Key Takeaway: These problems often involve breaking down a larger problem into smaller subproblems, with a focus on minimizing or maximizing a particular value.

Conclusion

Dynamic Programming is a vast topic, but by mastering these patterns, you can tackle almost any DP problem with confidence. Start with the basics, build your understanding of each pattern, and practice relentlessly. With time, you'll find that what once seemed complex becomes second nature, empowering you to solve even the most challenging problems efficiently.