What is Dynamic Programming?

Introduction

0/1 Knapsack

Solution: 0/1 Knapsack

Equal Subset Sum Partition

Solution: Equal Subset Sum Partition

Subset Sum

Solution: Subset Sum

Minimum Subset Sum Difference

Solution: Minimum Subset Sum Difference

Count of Subset Sum

Solution: Count of Subset Sum

Target Sum

Solution: Target Sum

Pattern 1: 0/1 Knapsack

Unbounded Knapsack

Solution: Unbounded Knapsack

Rod Cutting

Solution: Rod Cutting

Coin Change

Solution: Coin Change

Minimum Coin Change

Solution: Minimum Coin Change 

Maximum Ribbon Cut

Solution: Maximum Ribbon Cut

Pattern 2: Unbounded Knapsack

Fibonacci numbers

Solution: Fibonacci numbers

Staircase

Solution: Staircase

Number factors

Solution: Number factors

Minimum jumps to reach the end

Solution: Minimum jumps to reach the end

Minimum jumps with fee

Solution: Minimum jumps with fee

House thief

Solution: House thief

Pattern 3: Fibonacci Numbers

Longest Palindromic Subsequence

Solution: Longest Palindromic Subsequence

Longest Palindromic Substring

Solution: Longest Palindromic Substring

Count of Palindromic Substrings

Solution: Count of Palindromic Substrings

Minimum Deletions in a String to make it a Palindrome

Solution: Minimum Deletions in a String to make it a Palindrome

Palindromic Partitioning

Solution: Palindromic Partitioning

Pattern 4: Palindromic Subsequence

Longest Common Substring

Solution: Longest Common Substring

Longest Common Subsequence

Solution: Longest Common Subsequence

Minimum Deletions & Insertions to Transform a String into another

Solution: Minimum Deletions & Insertions to Transform a String into another

Longest Increasing Subsequence

Solution: Longest Increasing Subsequence

Maximum Sum Increasing Subsequence

Solution: Maximum Sum Increasing Subsequence

Shortest Common Super-sequence

Solution: Shortest Common Super-sequence

Minimum Deletions to Make a Sequence Sorted

Solution: Minimum Deletions to Make a Sequence Sorted

Longest Repeating Subsequence

Solution: Longest Repeating Subsequence

Subsequence Pattern Matching

Solution: Subsequence Pattern Matching

Longest Bitonic Subsequence

Solution: Longest Bitonic Subsequence

Longest Alternating Subsequence

Solution: Longest Alternating Subsequence

Edit Distance

Solution: Edit Distance

Strings Interleaving

Solution: Strings Interleaving

Pattern 5: Longest Common Substring

Contact Us

Appendix

Grokking Dynamic Programming Patterns for Coding Interviews

## Introduction

Given the weights and profits of 'N' items, we are asked to put these items in a knapsack that has a capacity 'C'. The goal is to get the maximum profit from the items in the knapsack. The only difference between the `"0/1 Knapsack"` problem and this problem is that we are allowed to use an unlimited quantity of an item.

Let's take the example of Merry, who wants to carry some fruits in the knapsack to get maximum profit. Here are the weights and profits of the fruits:

**Items:** { Apple, Orange, Melon }  
**Weights:** { 1, 2, 3 }  
**Profits:** { 15, 20, 50 }   
**Knapsack capacity:** 5

Let's try to put different combinations of fruits in the knapsack, such that their total weight is not more than 5.

5 Apples (total weight 5) => 75 profit   
1 Apple + 2 Oranges  (total weight 5) => 55 profit  
2 Apples + 1 Melon  (total weight 5) => 80 profit  
1 Orange + 1 Melon  (total weight 5) => 70 profit  

This shows that **2 apples + 1 melon** is the best combination, as it gives us the maximum profit and the total weight does not exceed the capacity.

## Problem Statement
Given two integer arrays to represent weights and profits of 'N' items, we need to find a subset of these items which will give us maximum profit such that their cumulative weight is not more than a given number 'C'. We can assume an infinite supply of item quantities; therefore, each item can be selected multiple times.

## Try it yourself #
Try solving this question here:
