Tabulation Bottom Up DP in DSA Javascript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is Tabulation in Dynamic Programming?

Tabulation is a bottom-up approach where we solve smaller subproblems first and store their results in a table (usually an array). Then, we use these results to solve bigger problems step by step.

beginner

How does Tabulation differ from Memoization?

Tabulation solves problems iteratively from the smallest subproblem up, filling a table. Memoization solves problems recursively and stores results to avoid repeated work.

intermediate

Why is Tabulation often preferred over Memoization?

Tabulation avoids recursion overhead, uses simple loops, and guarantees all subproblems are solved once. It often uses less memory and is easier to debug.

beginner

In Tabulation, what does the table usually represent?

The table stores answers to subproblems. Each entry corresponds to a smaller problem's solution, which helps build up to the final answer.

beginner

Example: How would you use Tabulation to find the nth Fibonacci number?

Create an array fib where fib[0] = 0, fib[1] = 1. Then fill fib[i] = fib[i-1] + fib[i-2] for i from 2 to n. The answer is fib[n].

What is the main idea behind Tabulation in Dynamic Programming?

A Solve the largest problem first and break it down

B Solve the problem recursively without storing results

C Use random guesses to find the solution

D Solve smaller problems first and build up solutions iteratively

Tabulation solves smaller subproblems first and uses their results to solve bigger problems step by step.

Which data structure is commonly used in Tabulation?

A Table or array

B Queue

C Linked list

D Stack

Tabulation uses a table or array to store results of subproblems.

What is a key advantage of Tabulation over Memoization?

A Avoids recursion overhead and is easier to debug

B Does not store any results

C Uses recursion

D Always faster than any other method

Tabulation avoids recursion overhead and is often easier to debug because it uses loops.

In the Fibonacci example using Tabulation, what is fib[2] equal to?

A 0

B 1

C 2

D 3

fib[2] = fib[1] + fib[0] = 1 + 0 = 1.

Which of these is NOT true about Tabulation?

A It stores results to avoid repeated work

B It fills a table from smallest to largest subproblems

C It uses recursion to solve subproblems

D It is a bottom-up approach

Tabulation uses iteration, not recursion.

Explain how Tabulation works in Dynamic Programming with an example.

Think about filling an array from the start to the end.

Compare Tabulation and Memoization in simple terms.

One uses loops, the other uses recursion.

Practice

1. What is the main idea behind Tabulation Bottom Up DP in dynamic programming?

easy

A. Build a table from the smallest subproblems up to the main problem

B. Solve the problem by recursion without storing results

C. Use random guesses to find the solution

D. Start solving from the biggest problem and break it down

Solution

1. Step 1: Understand bottom-up approach

   Tabulation means filling a table starting from the smallest subproblems to bigger ones.

2. Step 2: Compare with other methods

   Unlike recursion without storage, tabulation avoids repeated work by storing results in a table.

3. Final Answer:

   Build a table from the smallest subproblems up to the main problem -> Option A

4. Quick Check:

   Tabulation = Bottom-up table filling [OK]

Hint: Think: solve small parts first, then bigger [OK]

Common Mistakes:

• Confusing tabulation with recursion without memo
• Thinking tabulation starts from the biggest problem
• Ignoring the use of a table to store results

2. Which of the following is the correct way to initialize a tabulation array for Fibonacci numbers in JavaScript?

easy

A. const dp = [];

B. const dp = [0, 1];

C. const dp = [0, 0];

D. const dp = [1, 1];

Solution

1. Step 1: Recall Fibonacci base cases

   Fibonacci sequence starts with 0 and 1, so dp[0] = 0 and dp[1] = 1.

2. Step 2: Check initialization options

   Only const dp = [0, 1]; correctly sets dp = [0, 1] matching Fibonacci base values.

3. Final Answer:

   const dp = [0, 1]; -> Option B

4. Quick Check:

   Fibonacci base = [0,1] [OK]

Hint: Start dp with first two Fibonacci numbers [OK]

Common Mistakes:

• Starting dp with [1,1] which is incorrect base
• Initializing dp with zeros only
• Leaving dp empty without base values

3. What will be the output of the following JavaScript code using bottom-up DP to find Fibonacci number at position 5?

function fib(n) {
  const dp = [0, 1];
  for (let i = 2; i <= n; i++) {
    dp[i] = dp[i - 1] + dp[i - 2];
  }
  return dp[n];
}
console.log(fib(5));

medium

A. 3

B. 8

C. 5

D. 13

Solution

1. Step 1: Trace dp array filling

   dp[0]=0, dp[1]=1; then dp[2]=1, dp[3]=2, dp[4]=3, dp[5]=5.

2. Step 2: Return dp[5]

   The function returns dp[5] which is 5.

3. Final Answer:

   5 -> Option C

4. Quick Check:

   fib(5) = 5 [OK]

Hint: Remember Fibonacci sequence: 0,1,1,2,3,5... [OK]

Common Mistakes:

• Confusing index with Fibonacci value
• Returning dp[n-1] instead of dp[n]
• Starting dp with wrong base values

4. Find the error in this bottom-up DP code for Fibonacci numbers:

function fib(n) {
  const dp = [0, 1];
  for (let i = 1; i <= n; i++) {
    dp[i] = dp[i - 1] + dp[i - 2];
  }
  return dp[n];
}

medium

A. dp[i - 2] causes out-of-bound error

B. dp array is not initialized

C. Return statement is missing

D. Loop starts at 1 instead of 2

Solution

1. Step 1: Analyze loop start index

   The loop starts at i=1, but dp[1] is already initialized; calculation should start at i=2.

2. Step 2: Identify impact of wrong loop start

   At i=1, dp[1] = dp[0] + dp[-1] causes dp[-1] undefined, leading to NaN.

3. Final Answer:

   Loop starts at 1 instead of 2 -> Option D

4. Quick Check:

   Loop must start at 2 to avoid invalid index [OK]

Hint: Start loop at 2 to avoid negative index [OK]

Common Mistakes:

• Starting loop at 1 causing invalid dp[-1]
• Ignoring dp initialization
• Assuming dp[-1] is zero

5. Given the problem to find the minimum number of coins to make amount 7 using coins [1, 3, 4], which bottom-up DP table entry represents the minimum coins needed for amount 5?
Assuming dp[0] = 0 and dp[i] = Infinity initially for i > 0, what is dp[5] after filling the table?

hard

A. 2

B. 3

C. 1

D. Infinity

Solution

1. Step 1: Fill dp table for amounts up to 5

   dp[0]=0; dp[1]=1 (1 coin of 1); dp[2]=2 (1+1); dp[3]=1 (coin 3); dp[4]=1 (coin 4); dp[5]=min(dp[5-1], dp[5-3], dp[5-4]) +1 = min(dp[4], dp[2], dp[1]) +1 = min(1,2,1)+1=2.

2. Step 2: Confirm dp[5] value

   Minimum coins for amount 5 is 2.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   dp[5] = 2 coins [OK]

Hint: Check all coin options and pick minimum +1 [OK]

Common Mistakes:

• Not considering all coin choices for dp[i]
• Using wrong initial dp values
• Confusing amount with coin count