Unbounded Knapsack Problem in DSA Typescript - Deep Dive

Overview - Unbounded Knapsack Problem

What is it?

The Unbounded Knapsack Problem is a classic challenge where you have a bag with a weight limit and many items, each with a weight and value. Unlike the regular knapsack problem, you can use each item as many times as you want. The goal is to fill the bag to get the highest total value without exceeding the weight limit. It helps us learn how to make the best choices when resources can be repeated.

Why it matters

This problem exists because in many real-life situations, you can use things multiple times, like buying unlimited supplies or cutting materials repeatedly. Without this concept, we wouldn't know how to maximize value efficiently when repetition is allowed. It helps businesses, engineers, and programmers make smart decisions to save money and time.

Where it fits

Before learning this, you should understand basic programming, arrays, and the 0/1 Knapsack Problem where items can only be used once. After this, you can explore more complex optimization problems like the Coin Change problem or advanced dynamic programming techniques.

Mental Model

Core Idea

Choose items repeatedly to fill the bag for maximum value without exceeding the weight limit.

Think of it like...

Imagine you have a basket that can carry a certain weight, and you have unlimited boxes of different fruits. You want to fill your basket with fruits to get the most deliciousness, and you can pick as many boxes of each fruit as you want.

Weight Limit (W)
┌───────────────────────────────┐
│                               │
│   +-----------------------+   │
│   | Item 1 (weight, value) |   │
│   +-----------------------+   │
│   +-----------------------+   │
│   | Item 2 (weight, value) |   │
│   +-----------------------+   │
│   +-----------------------+   │
│   | Item 3 (weight, value) |   │
│   +-----------------------+   │
│                               │
│   Use items any number of times│
└───────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding the Problem Setup

Concept: Introduce the problem of filling a bag with unlimited items to maximize value without exceeding weight.

You have a bag that can carry a maximum weight W. There are N types of items, each with a weight and a value. You can pick any number of each item. Your goal is to find the combination of items that gives the highest total value without the total weight going over W.

Result

You understand the problem goal and constraints clearly.

Understanding the problem setup is crucial because it defines the rules and what you are trying to optimize.

2

Foundation

Difference from 0/1 Knapsack Problem

Concept: Explain how unbounded knapsack allows unlimited use of items, unlike 0/1 knapsack.

In 0/1 Knapsack, you can only pick each item once. In Unbounded Knapsack, you can pick each item multiple times. This changes how we think about the problem because repetition is allowed, so the solution needs to consider multiple counts of the same item.

Result

You can distinguish between 0/1 and unbounded knapsack problems.

Knowing this difference helps you choose the right approach and avoid confusion when solving similar problems.

3

Intermediate

Dynamic Programming Approach Setup

Concept: Introduce the idea of using dynamic programming to solve the problem efficiently.

We create an array dp where dp[w] represents the maximum value achievable with weight limit w. We start from 0 and go up to W. For each weight w, we check all items. If the item's weight is less than or equal to w, we update dp[w] with the maximum of its current value and dp[w - item's weight] + item's value.

Result

You have a plan to solve the problem using a bottom-up approach.

Understanding the dp array as storing best values for smaller weights builds the foundation for efficient problem solving.

4

Intermediate

Implementing the DP Solution in TypeScript

🤔Before reading on: Do you think we should loop over weights first or items first? Commit to your answer.

Concept: Show how to write the code to fill the dp array and find the answer.

const unboundedKnapsack = (weights: number[], values: number[], W: number): number => { const dp = new Array(W + 1).fill(0); for (let w = 0; w <= W; w++) { for (let i = 0; i < weights.length; i++) { if (weights[i] <= w) { dp[w] = Math.max(dp[w], dp[w - weights[i]] + values[i]); } } } return dp[W]; }; // Example: // weights = [2, 3, 5], values = [50, 70, 100], W = 8 // Output: 200 (e.g., 4 items of weight 2 and value 50 each) console.log(unboundedKnapsack([2, 3, 5], [50, 70, 100], 8));

Result

200

Knowing the order of loops affects the solution correctness and efficiency is key to mastering dynamic programming.

5

Intermediate

Tracing the DP Array Updates

🤔Before reading on: At weight 5, do you think dp[5] will be updated by item with weight 2 or 3 first? Commit to your answer.

Concept: Walk through how dp array values change step-by-step for a small example.

Start with dp = [0,0,0,0,0,0,0,0,0] for W=8. - For w=2: dp[2] = max(dp[2], dp[0]+50) = 50 - For w=3: dp[3] = max(dp[3], dp[0]+70) = 70 - For w=4: dp[4] = max(dp[4], dp[2]+50) = 100 - For w=5: dp[5] = max(dp[5], dp[3]+50, dp[2]+70, dp[0]+100) = 120 ... and so on until dp[8] = 200.

Result

You see how dp array builds up the solution incrementally.

Tracing the dp updates reveals how smaller solutions combine to solve bigger problems.

6

Advanced

Optimizing Space and Time Complexity

🤔Before reading on: Do you think we can reduce the dp array size or skip some computations? Commit to your answer.

Concept: Discuss how the current solution uses O(W*N) time and O(W) space, and possible optimizations.

The solution uses a one-dimensional dp array of size W+1, which is already space efficient. Time complexity is O(W*N) because for each weight, we check all items. We cannot reduce dp size further because we need all weights up to W. However, sorting items by value/weight ratio or pruning can help in some cases.

Result

You understand the efficiency limits and possible improvements.

Knowing complexity helps you decide if this approach fits your problem size or if you need heuristics.

7

Expert

Handling Large Inputs and Real-World Constraints

🤔Before reading on: Do you think the DP approach always works well for very large W? Commit to your answer.

Concept: Explore challenges with very large weight limits and how to handle them in practice.

When W is very large, the dp array becomes huge, causing memory and time issues. Alternatives include using greedy methods if items have special properties, approximation algorithms, or problem-specific heuristics. Sometimes, scaling down weights or using integer programming solvers is better.

Result

You know when to switch from DP to other methods for large-scale problems.

Understanding practical limits prevents wasted effort on infeasible solutions and guides you to better tools.

Under the Hood

The dp array stores the best value achievable for every weight from 0 to W. For each weight, the algorithm tries all items that fit and updates the dp value by considering adding that item again. This works because the problem has optimal substructure: the best solution for weight w depends on best solutions for smaller weights.

Why designed this way?

This approach was designed to avoid redundant calculations by storing intermediate results. It builds on the principle of dynamic programming, which breaks problems into smaller overlapping subproblems. Alternatives like recursion with memoization exist but are less efficient for large inputs.

Weight (w): 0 1 2 3 4 5 6 7 8
DP array:  dp[0] dp[1] dp[2] dp[3] dp[4] dp[5] dp[6] dp[7] dp[8]
          [0]   [0]   [50]  [70]  [100] [120] [150] [170] [200]

For each w:
  ┌───────────────┐
  │ For each item: │
  │ if item.weight ≤ w:
  │   dp[w] = max(dp[w], dp[w - item.weight] + item.value)
  └───────────────┘

Myth Busters - 3 Common Misconceptions

Quick: Can you use each item only once in the unbounded knapsack? Commit yes or no.

Common Belief: Unbounded knapsack means you can only use each item once, just like 0/1 knapsack.

Reality: Unbounded knapsack allows unlimited use of each item, unlike 0/1 knapsack where each item is used at most once.

Why it matters: Confusing these leads to wrong solutions and missed opportunities to maximize value.

Quick: Does the order of looping over weights and items affect the solution? Commit yes or no.

Common Belief: The order of loops in the DP solution does not affect the final answer.

Reality: The order matters; looping weights first then items ensures correct calculation for unbounded knapsack.

Why it matters: Wrong loop order can produce incorrect results or mimic 0/1 knapsack behavior.

Quick: Is it always best to pick the item with the highest value first? Commit yes or no.

Common Belief: Always pick the item with the highest value first to maximize total value.

Reality: Picking highest value items first without considering weight can exceed capacity or miss better combinations.

Why it matters: Greedy choices without dynamic programming can lead to suboptimal solutions.

Expert Zone

1

The order of loops in the DP solution changes the problem from unbounded to 0/1 knapsack if reversed.

2

When items have weights that are multiples of each other, the problem can be optimized by grouping or skipping redundant states.

3

Floating point weights require careful scaling or alternative algorithms because DP arrays rely on integer indices.

When NOT to use

Avoid unbounded knapsack DP when the weight limit W is extremely large (e.g., millions or more), or when items have fractional weights. Instead, use approximation algorithms, greedy heuristics, or integer linear programming.

Production Patterns

Used in resource allocation where supplies are unlimited, like cutting raw materials, coin change problems, or maximizing profit with repeatable offers. Often combined with memoization or pruning in real systems to handle large inputs.

Connections

Coin Change Problem

Builds-on and closely related problem where you count ways or minimize coins using unlimited items.

Understanding unbounded knapsack helps solve coin change because both use similar DP structures with unlimited item usage.

Dynamic Programming

Core technique used to solve unbounded knapsack efficiently by breaking down problems into subproblems.

Mastering unbounded knapsack deepens understanding of dynamic programming principles like optimal substructure and overlapping subproblems.

Economics - Resource Allocation

Real-world application where limited budget (weight) is allocated to repeated investments (items) to maximize returns (value).

Seeing unbounded knapsack as resource allocation clarifies why repetition and optimization matter in business decisions.

Common Pitfalls

#1 Using 0/1 knapsack DP loop order for unbounded knapsack.

Wrong approach:

for (let i = 0; i < items.length; i++) {
for (let w = W; w >= weights[i]; w--) {
dp[w] = Math.max(dp[w], dp[w - weights[i]] + values[i]);
}
}

Correct approach:

for (let w = 0; w <= W; w++) {
for (let i = 0; i < items.length; i++) {
if (weights[i] <= w) {
dp[w] = Math.max(dp[w], dp[w - weights[i]] + values[i]);
}
}
}

Root cause:

Confusing loop order causes the algorithm to treat items as if they can only be used once.

#2 Not initializing dp array properly or using wrong size.

Wrong approach:

const dp = new Array(W).fill(0); // size W instead of W+1

Correct approach:

const dp = new Array(W + 1).fill(0);

Root cause:

Off-by-one errors cause missing states and incorrect results.

#3 Trying to solve unbounded knapsack with greedy approach only.

Wrong approach:

Sort items by value descending and pick as many as possible from highest value item first.

Correct approach:

Use dynamic programming to consider all combinations and repetitions.

Root cause:

Greedy approach ignores combinations and can miss better overall solutions.

Key Takeaways

Unbounded Knapsack allows unlimited use of each item to maximize value within a weight limit.

Dynamic programming solves it efficiently by building solutions from smaller weights up to the limit.

The order of loops in the DP solution is critical to correctly handle unlimited item usage.

Real-world problems like resource allocation and coin change are closely related and benefit from this approach.

Understanding practical limits helps choose the right method for large or complex inputs.

Practice

1. What is the main difference between the 0/1 Knapsack Problem and the Unbounded Knapsack Problem?

easy

A. In Unbounded Knapsack, you can use unlimited copies of each item.

B. In Unbounded Knapsack, items cannot be repeated.

C. Unbounded Knapsack only works with fractional items.

D. Unbounded Knapsack has a fixed number of items to choose from.

Solution

1. Step 1: Understand the item usage rules

   In 0/1 Knapsack, each item can be chosen at most once. In Unbounded Knapsack, items can be chosen unlimited times.

2. Step 2: Compare the problem constraints

   Unbounded Knapsack allows repeated use of the same item, unlike 0/1 Knapsack.

3. Final Answer:

   In Unbounded Knapsack, you can use unlimited copies of each item. -> Option A

4. Quick Check:

   Unlimited item usage = In Unbounded Knapsack, you can use unlimited copies of each item. [OK]

Hint: Unbounded means unlimited items allowed [OK]

Common Mistakes:

• Confusing unbounded with fractional knapsack
• Thinking items cannot repeat
• Assuming fixed item count

2. Which of the following TypeScript function signatures correctly represents the Unbounded Knapsack function?

easy

A. function unboundedKnapsack(W: number, wt: string[], val: number[], n: number): number

B. function unboundedKnapsack(W: string, wt: number[], val: number[], n: number): number

C. function unboundedKnapsack(W: number, wt: number[], val: number[], n: number): number

D. function unboundedKnapsack(W: number, wt: number[], val: number[], n: string): number

Solution

1. Step 1: Check parameter types for correctness

   Weight capacity W should be a number, weights wt and values val arrays of numbers, and n the number of items as a number.

2. Step 2: Identify the correct signature

   function unboundedKnapsack(W: number, wt: number[], val: number[], n: number): number matches all types correctly. Others have wrong types like string instead of number.

3. Final Answer:

   function unboundedKnapsack(W: number, wt: number[], val: number[], n: number): number -> Option C

4. Quick Check:

   Correct types for all parameters = function unboundedKnapsack(W: number, wt: number[], val: number[], n: number): number [OK]

Hint: Check parameter types carefully [OK]

Common Mistakes:

• Using string instead of number for weights or capacity
• Mixing array types
• Incorrect return type

3. What will be the output of the following TypeScript code snippet for Unbounded Knapsack?

const val = [10, 40, 50];
const wt = [1, 3, 4];
const W = 6;

function unboundedKnapsack(W: number, wt: number[], val: number[], n: number): number {
  const dp = Array(W + 1).fill(0);
  for (let i = 1; i <= W; i++) {
    for (let j = 0; j < n; j++) {
      if (wt[j] <= i) {
        dp[i] = Math.max(dp[i], dp[i - wt[j]] + val[j]);
      }
    }
  }
  return dp[W];
}

console.log(unboundedKnapsack(W, wt, val, val.length));

medium

A. 90

B. 100

C. 120

D. 80

Solution

1. Step 1: Understand the DP array construction

   We build dp array from 0 to W=6. For each capacity, we check all items and update dp[i] with max value including unlimited items.

2. Step 2: Calculate dp values step-by-step

   dp[1]=max(0, dp[0]+10)=10
   dp[2]=max(0, dp[1]+10)=20
   dp[3]=max(dp[3], dp[0]+40)=40, also dp[3]=max(40, dp[2]+10)=40
   dp[4]=max(dp[4], dp[1]+40)=50, also dp[4]=max(50, dp[0]+50)=50
   dp[5]=max(dp[5], dp[2]+40)=60, also dp[5]=max(60, dp[1]+50)=60
   dp[6]=max(dp[6], dp[3]+40)=80, also dp[6]=max(80, dp[2]+50)=90

3. Final Answer:

   90 -> Option A

4. Quick Check:

   Max value for W=6 = 90 [OK]

Hint: Build dp array incrementally for each capacity [OK]

Common Mistakes:

• Not considering multiple copies of items
• Incorrect dp array updates
• Mixing 0/1 and unbounded logic

4. Identify the bug in this Unbounded Knapsack TypeScript code snippet:

function unboundedKnapsack(W: number, wt: number[], val: number[], n: number): number {
  const dp = Array(W + 1).fill(0);
  for (let j = 0; j < n; j++) {
    for (let i = 1; i <= W; i++) {
      if (wt[j] <= i) {
        dp[i] = Math.max(dp[i], dp[i - wt[j]] + val[j]);
      }
    }
  }
  return dp[W];
}

medium

A. The condition wt[j] <= i should be wt[j] < i

B. Initialization of dp array is incorrect

C. Return statement should be dp[0] instead of dp[W]

D. Loops are reversed; inner loop should be over items, outer over capacity

Solution

1. Step 1: Analyze loop order for unbounded knapsack

   For unbounded knapsack, outer loop should iterate over capacities (i), inner loop over items (j) to allow multiple uses of items.

2. Step 2: Identify the bug in loop order

   Here, outer loop is over items and inner over capacity, which is incorrect and leads to wrong results.

3. Final Answer:

   Loops are reversed; inner loop should be over items, outer over capacity -> Option D

4. Quick Check:

   Correct loop order = capacity outer, items inner [OK]

Hint: Outer loop on capacity for unbounded knapsack [OK]

Common Mistakes:

• Swapping loop order
• Wrong dp initialization
• Incorrect return index

5. Given items with values val = [5, 10, 15] and weights wt = [1, 3, 4], and a knapsack capacity W = 7, what is the maximum value achievable using the Unbounded Knapsack approach?

hard

A. 25

B. 30

C. 35

D. 40

Solution

1. Step 1: Calculate dp array values for capacities 1 to 7

   dp[0]=0
   dp[1]=max(0, dp[0]+5)=5
   dp[2]=max(0, dp[1]+5)=10
   dp[3]=max(dp[3], dp[0]+10)=10, also dp[3]=max(10, dp[2]+5)=10
   dp[4]=max(dp[4], dp[1]+10)=15, also dp[4]=max(15, dp[0]+15)=15
   dp[5]=max(dp[5], dp[2]+10)=20, also dp[5]=max(20, dp[1]+15)=20
   dp[6]=max(dp[6], dp[3]+10)=20, also dp[6]=max(20, dp[2]+15)=25
   dp[7]=max(dp[7], dp[4]+10)=25, also dp[7]=max(25, dp[3]+15)=25

2. Step 2: Find maximum value at capacity 7

   The maximum value achievable is 25, but check if better combinations exist:
   Try dp[7] = dp[3] + val[2] = 10 + 15 = 25
   Try dp[7] = dp[4] + val[1] = 15 + 10 = 25
   Try dp[7] = dp[6] + val[0] = 25 + 5 = 30 (better)
   Update dp[7] = 30
   Try dp[7] = dp[3] + val[2] = 10 + 15 = 25 (less than 30)
   So final dp[7] = 30

3. Final Answer:

   30 -> Option B

4. Quick Check:

   Maximum value for W=7 = 30 [OK]

Hint: Check all item combinations for each capacity [OK]

Common Mistakes:

• Ignoring multiple item usage
• Stopping at first max value found
• Not updating dp array correctly