Unbounded Knapsack Problem in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the dp array with zeros.

DSA Typescript

const dp: number[] = new Array([1] + 1).fill(0);

Drag options to blanks, or click blank then click option'

Acapacity

Bweights.length

Cvalues.length

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using the number of items instead of capacity for dp size.

Not adding 1 to capacity for dp array length.

We create a dp array of size capacity + 1 to store maximum values for each capacity from 0 to capacity.

2fill in blank

medium

Complete the code to iterate over all capacities from 1 to capacity.

DSA Typescript

for (let cap = 1; cap <= [1]; cap++) {

Drag options to blanks, or click blank then click option'

Avalues.length

Bcapacity

Cweights.length

Ddp.length

Attempts:

3 left

💡 Hint

Common Mistakes

Using dp.length which is capacity + 1, causing off-by-one errors.

Using number of items instead of capacity.

We loop from 1 to capacity to fill dp for all capacities.

3fill in blank

hard

Fix the error in the condition to check if the current item can fit in the current capacity.

DSA Typescript

if (weights[i] [1] cap) {

Drag options to blanks, or click blank then click option'

A<=

B>

C==

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using > which is the opposite condition.

Using == which misses items that are lighter than capacity.

We check if the item's weight is less than or equal to the current capacity to decide if it fits.

4fill in blank

hard

Fill both blanks to update dp[cap] with the maximum value including the current item.

DSA Typescript

dp[cap] = Math.max(dp[cap], dp[cap - [1]] + [2]);

Drag options to blanks, or click blank then click option'

Aweights[i]

Bvalues[i]

Ccap

Di

Attempts:

3 left

💡 Hint

Common Mistakes

Using cap instead of weights[i] for subtraction.

Adding weights[i] instead of values[i].

We subtract the item's weight from capacity and add its value to find the new max value.

5fill in blank

hard

Fill all three blanks to complete the unbounded knapsack function.

DSA Typescript

function unboundedKnapsack([1]: number[], [2]: number, [3]: number[]): number {
  const dp: number[] = new Array([2] + 1).fill(0);
  for (let cap = 1; cap <= [2]; cap++) {
    for (let i = 0; i < [1].length; i++) {
      if ([1][i] <= cap) {
        dp[cap] = Math.max(dp[cap], dp[cap - [1][i]] + [3][i]);
      }
    }
  }
  return dp[[2]];
}

Drag options to blanks, or click blank then click option'

Aweights

Bcapacity

Cvalues

Ditems

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up weights and values parameter order.

Using incorrect variable names inside the function.

The function takes weights, capacity, and values arrays to compute the maximum value for unbounded knapsack.

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