Memoization Top Down DP in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Fibonacci with Memoization

What is the output of the following Java code that uses memoization to compute Fibonacci numbers?

DSA Java

import java.util.*;
public class Main {
    static Map<Integer, Integer> memo = new HashMap<>();
    public static int fib(int n) {
        if (n <= 1) return n;
        if (memo.containsKey(n)) return memo.get(n);
        int result = fib(n - 1) + fib(n - 2);
        memo.put(n, result);
        return result;
    }
    public static void main(String[] args) {
        System.out.println(fib(6));
    }
}

A 8

B 21

C 13

D 34

💡 Hint

Recall the Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13...

The code computes fib(6) using memoization. fib(6) = fib(5) + fib(4) = 5 + 3 = 8.

❓ Predict Output

intermediate

Memoized Climbing Stairs Output

What is the output of this Java code that uses memoization to count ways to climb stairs?

DSA Java

import java.util.*;
public class Main {
    static Map<Integer, Integer> memo = new HashMap<>();
    public static int climbStairs(int n) {
        if (n <= 1) return 1;
        if (memo.containsKey(n)) return memo.get(n);
        int ways = climbStairs(n - 1) + climbStairs(n - 2);
        memo.put(n, ways);
        return ways;
    }
    public static void main(String[] args) {
        System.out.println(climbStairs(4));
    }
}

A 8

B 7

C 5

D 6

💡 Hint

Number of ways to climb 4 stairs with 1 or 2 steps at a time.

Ways to climb 4 stairs = ways(3) + ways(2) = 3 + 2 = 5.

🔧 Debug

advanced

Identify the Bug in Memoized Fibonacci

What error will this Java code produce when run?

DSA Java

import java.util.*;
public class Main {
    static Map<Integer, Integer> memo = new HashMap<>();
    public static int fib(int n) {
        if (n == 0 || n == 1) return n;
        if (memo.containsKey(n)) return memo.get(n);
        int result = fib(n - 1) + fib(n - 3);
        memo.put(n, result);
        return result;
    }
    public static void main(String[] args) {
        System.out.println(fib(5));
    }
}

A StackOverflowError

B 5

C 0

D Compilation error

💡 Hint

Check recursive calls and base cases carefully.

fib(n) calls fib(n-3) without base case for n<0, causing infinite recursion and StackOverflowError.

❓ Predict Output

advanced

Output of Memoized Coin Change Count

What is the output of this Java code that counts ways to make change using memoization?

DSA Java

import java.util.*;
public class Main {
    static Map<String, Integer> memo = new HashMap<>();
    public static int countWays(int[] coins, int n, int index) {
        if (n == 0) return 1;
        if (n < 0 || index == coins.length) return 0;
        String key = n + "," + index;
        if (memo.containsKey(key)) return memo.get(key);
        int ways = countWays(coins, n - coins[index], index) + countWays(coins, n, index + 1);
        memo.put(key, ways);
        return ways;
    }
    public static void main(String[] args) {
        int[] coins = {1, 2, 5};
        System.out.println(countWays(coins, 5, 0));
    }
}

A 6

B 4

C 5

D 7

💡 Hint

Count all combinations of coins to make 5.

Ways to make 5 with {1,2,5} are 4: {1,1,1,1,1}, {1,1,1,2}, {1,2,2}, {5}.

🧠 Conceptual

expert

Memoization Cache Size for Top-Down DP

Consider a top-down memoized DP solution for a problem with input parameter n. If the recursive function calls itself with parameters from 0 up to n, what is the maximum number of entries stored in the memoization cache?

A O(1) entry

B O(n^2) entries

C O(log n) entries

D O(n) entries

💡 Hint

Think about how many unique states the function can have.

If the function parameter ranges from 0 to n, the memo cache stores at most one entry per unique parameter value, so O(n).

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