Memoization Top Down DP in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the memo array with -1.

DSA Java

int[] memo = new int[n + 1];
for (int i = 0; i < memo.length; i++) {
    memo[i] = [1];
}

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

A-1

B0

C1

DInteger.MAX_VALUE

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing memo with 0 which can cause confusion with computed zero values.

We use -1 to indicate that the value has not been computed yet in memoization.

2fill in blank

medium

Complete the code to check if the result is already computed in memo.

DSA Java

if (memo[n] != [1]) {
    return memo[n];
}

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

A-1

B0

Cn

DInteger.MAX_VALUE

Attempts:

3 left

💡 Hint

Common Mistakes

Checking for 0 instead of -1, causing incorrect reuse of uninitialized values.

If memo[n] is not -1, it means the value was computed before and can be returned directly.

3fill in blank

hard

Fix the error in the recursive call to compute the Fibonacci number with memoization.

DSA Java

public int fib(int n, int[] memo) {
    if (n <= 1) return n;
    if (memo[n] != -1) return memo[n];
    memo[n] = fib([1], memo) + fib(n - 2, memo);
    return memo[n];
}

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

An + 1

Bn - 2

Cn - 1

Dn

Attempts:

3 left

💡 Hint

Common Mistakes

Using n or n-2 for both recursive calls, which is incorrect.

The Fibonacci number is computed as fib(n-1) + fib(n-2), so the first recursive call must be fib(n-1).

4fill in blank

hard

Fill both blanks to complete the memoized factorial function.

DSA Java

public int factorial(int n, int[] memo) {
    if (n <= 1) return 1;
    if (memo[n] != [1]) return memo[n];
    memo[n] = n * factorial([2], memo);
    return memo[n];
}

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

A-1

B0

Cn - 1

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 instead of -1 for memo check.

Calling factorial with n instead of n-1.

We check if memo[n] is not -1 to reuse computed values, and recursively call factorial with n-1.

5fill in blank

hard

Fill all three blanks to complete the memoized function for computing the nth Tribonacci number.

DSA Java

public int tribonacci(int n, int[] memo) {
    if (n == 0) return 0;
    if (n == 1 || n == 2) return 1;
    if (memo[n] != [1]) return memo[n];
    memo[n] = tribonacci([2], memo) + tribonacci([3], memo) + tribonacci(n - 3, memo);
    return memo[n];
}

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

A-1

Bn - 1

Cn - 2

Dn - 3

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong indices in recursive calls.

Checking memo with 0 instead of -1.

We check memo[n] against -1, then compute tribonacci(n-1) + tribonacci(n-2) + tribonacci(n-3).

Practice

1. What is the main purpose of memoization in top-down dynamic programming?

easy

A. To increase the size of the input for better accuracy

B. To sort the input data before processing

C. To store results of subproblems to avoid repeated calculations

D. To convert recursive code into iterative code

Solution

1. Step 1: Understand memoization role

   Memoization saves answers of smaller problems so they are not recalculated.

2. Step 2: Compare options

   Only To store results of subproblems to avoid repeated calculations correctly describes storing subproblem results to avoid repeats.

3. Final Answer:

   To store results of subproblems to avoid repeated calculations -> Option C

4. Quick Check:

   Memoization = store subproblem results [OK]

Hint: Memoization means saving answers to reuse later [OK]

Common Mistakes:

• Confusing memoization with sorting
• Thinking memoization changes recursion to iteration
• Believing memoization increases input size

2. Which of the following is the correct way to declare a memo array for Fibonacci numbers in Java?

easy

A. int memo[] = new int();

B. int memo = new int[n];

C. int[] memo = new int[];

D. int[] memo = new int[n+1];

Solution

1. Step 1: Check Java array declaration syntax

   Correct syntax for array with size n+1 is: int[] memo = new int[n+1];

2. Step 2: Identify errors in other options

   int memo = new int[n]; declares int, not array; C misses size; D uses wrong constructor syntax.

3. Final Answer:

   int[] memo = new int[n+1]; -> Option D

4. Quick Check:

   Array declaration = int[] memo = new int[size] [OK]

Hint: Use int[] memo = new int[n+1] for memo arrays [OK]

Common Mistakes:

• Declaring memo as int instead of int[]
• Not specifying array size when creating
• Using parentheses instead of brackets for arrays

3. What will be the output of the following Java code using memoization for Fibonacci?

public class FibMemo {
  static int[] memo;
  public static int fib(int n) {
    if (n <= 1) return n;
    if (memo[n] != -1) return memo[n];
    memo[n] = fib(n-1) + fib(n-2);
    return memo[n];
  }
  public static void main(String[] args) {
    int n = 5;
    memo = new int[n+1];
    for (int i = 0; i <= n; i++) memo[i] = -1;
    System.out.println(fib(n));
  }
}

medium

A. 5

B. 8

C. 3

D. Error due to uninitialized memo

Solution

1. Step 1: Understand Fibonacci calculation with memo

   fib(5) = fib(4) + fib(3), recursively calculated and stored in memo.

2. Step 2: Calculate fib(5) step-by-step

   fib(0)=0, fib(1)=1, fib(2)=1, fib(3)=2, fib(4)=3, fib(5)=5.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   fib(5) = 5 [OK]

Hint: Remember fib(5) = 5 in Fibonacci sequence [OK]

Common Mistakes:

• Confusing fib(5) with fib(6)
• Forgetting to initialize memo with -1
• Assuming memo causes errors if not initialized

4. Identify the bug in this memoized Fibonacci code snippet:

static int fib(int n, int[] memo) {
  if (n <= 1) return n;
  if (memo[n] != 0) return memo[n];
  memo[n] = fib(n-1, memo) + fib(n-2, memo);
  return memo[n];
}

public static void main(String[] args) {
  int n = 4;
  int[] memo = new int[n+1];
  System.out.println(fib(n, memo));
}

medium

A. Memo array not initialized with -1, causing wrong cache checks

B. Base case should return 0 for n <= 1

C. Memo array size is too small

D. fib function missing return statement

Solution

1. Step 1: Check memo initialization and cache check

   Memo array defaults to 0; fib(0)=0, so memo[n]!=0 check fails for fib(0).

2. Step 2: Explain why -1 initialization is needed

   Initialize memo with -1 to distinguish uncalculated from zero results.

3. Final Answer:

   Memo array not initialized with -1, causing wrong cache checks -> Option A

4. Quick Check:

   Initialize memo with -1 to avoid false cache hits [OK]

Hint: Initialize memo with -1 to mark unvisited states [OK]

Common Mistakes:

• Assuming 0 means unvisited in memo
• Changing base case incorrectly
• Using wrong memo array size

5. Given the top-down memoized code for the coin change problem below, what is the output for coins = {1, 2} and amount = 4?

public class CoinChange {
  static int[] memo;
  public static int countWays(int amount, int[] coins) {
    if (amount == 0) return 1;
    if (amount < 0) return 0;
    if (memo[amount] != -1) return memo[amount];
    int ways = 0;
    for (int coin : coins) {
      ways += countWays(amount - coin, coins);
    }
    memo[amount] = ways;
    return ways;
  }
  public static void main(String[] args) {
    int[] coins = {1, 2};
    int amount = 4;
    memo = new int[amount + 1];
    for (int i = 0; i <= amount; i++) memo[i] = -1;
    System.out.println(countWays(amount, coins));
  }
}

hard

A. 4

B. 5

C. 3

D. 6

Solution

1. Step 1: Understand problem and recursion

   Count ways to make 4 using coins 1 and 2, summing ways for amount-coin recursively.

2. Step 2: Calculate ways for amount=4

   Ways(4) = Ways(3)+Ways(2); Ways(3)=Ways(2)+Ways(1); Ways(2)=Ways(1)+Ways(0); Ways(1)=Ways(0)+Ways(-1); base cases: Ways(0)=1, Ways(-1)=0.

3. Step 3: Calculate values bottom-up

   Ways(0)=1; Ways(1)=1+0=1; Ways(2)=1+1=2; Ways(3)=2+1=3; Ways(4)=3+2=5.

4. Step 4: Re-check sum

   Actually, the code counts permutations, so for amount=4 with coins {1,2}, total ways = 5.

5. Final Answer:

   5 -> Option B

6. Quick Check:

   Number of ways to make 4 with {1,2} = 5 [OK]

Hint: Count ways recursively, memoize to avoid repeats [OK]

Common Mistakes:

• Confusing combinations with permutations
• Not initializing memo with -1
• Miscounting base cases