Overlapping Subproblems and Optimal Substructure in DSA C++ - Build from Scratch

Understanding Overlapping Subproblems and Optimal Substructure with Fibonacci Numbers

📖 Scenario: Imagine you want to find the number of ways to climb stairs where you can take 1 or 2 steps at a time. This problem is similar to calculating Fibonacci numbers, which helps us understand two important ideas in algorithms: overlapping subproblems and optimal substructure.

🎯 Goal: You will build a simple program to calculate Fibonacci numbers using recursion and then improve it using a technique called memoization. This will show how overlapping subproblems and optimal substructure work together to make algorithms efficient.

📋 What You'll Learn

Create a recursive function to calculate Fibonacci numbers

Add a memoization array to store results of subproblems

Use the memoization array to avoid repeated calculations

Print the Fibonacci number for a given input

💡 Why This Matters

🌍 Real World

Many problems in computer science, like pathfinding, resource allocation, and sequence analysis, use these ideas to solve complex tasks efficiently.

💼 Career

Understanding these concepts helps in optimizing code and solving problems faster, skills highly valued in software development and data science roles.

1

Create a recursive Fibonacci function

Write a recursive function called fib that takes an int n and returns the Fibonacci number for n. Use the base cases fib(0) = 0 and fib(1) = 1. For other values, return fib(n-1) + fib(n-2).

DSA C++

#include 

int fib(int n) {
    // Write the recursive Fibonacci function here
}

int main() {
    int n = 5;
    std::cout << fib(n) << std::endl;
    return 0;
}

Hint

Use simple if statements for the base cases and return the sum of two recursive calls for other cases.

2

Add a memoization array to store results

Declare a global integer array called memo of size 100 and initialize all elements to -1. This array will store Fibonacci results to avoid repeated calculations.

DSA C++

#include 

int memo[100]; // Initialize all elements to -1

int fib(int n) {
    if (n == 0) return 0;
    if (n == 1) return 1;
    return fib(n - 1) + fib(n - 2);
}

int main() {
    int n = 5;
    std::cout << fib(n) << std::endl;
    return 0;
}

Hint

Use a for loop in main to set all memo elements to -1.

3

Use memoization in the Fibonacci function

Modify the fib function to use the memo array. Before computing, check if memo[n] is not -1. If so, return memo[n]. Otherwise, compute the value, store it in memo[n], and then return it.

DSA C++

#include 

int memo[100];

int fib(int n) {
    // Use memoization to avoid repeated calculations
}

int main() {
    for (int i = 0; i < 100; i++) {
        memo[i] = -1;
    }
    int n = 5;
    std::cout << fib(n) << std::endl;
    return 0;
}

Hint

Check memo[n] before recursion and store the result after computing.

4

Print the Fibonacci number for n = 10

Change the value of n in main to 10 and print the Fibonacci number by calling fib(n).

DSA C++

#include 

int memo[100];

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

int main() {
    for (int i = 0; i < 100; i++) {
        memo[i] = -1;
    }
    int n = 10; // Change n to 10
    std::cout << fib(n) << std::endl;
    return 0;
}

Hint

Remember to update n to 10 and print the result.

Practice

1. Which of the following best describes the property of Overlapping Subproblems in dynamic programming?

easy

A. The problem can be broken down into smaller subproblems which are solved multiple times.

B. The problem has a unique solution without repeating any subproblems.

C. The problem requires sorting before solving.

D. The problem can only be solved using recursion without memoization.

Solution

1. Step 1: Understand Overlapping Subproblems

   Overlapping subproblems means the same smaller problems appear multiple times during the solution process.

2. Step 2: Match the definition to options

   The problem can be broken down into smaller subproblems which are solved multiple times. correctly states that subproblems are solved multiple times, which is the key idea behind overlapping subproblems.

3. Final Answer:

   The problem can be broken down into smaller subproblems which are solved multiple times. -> Option A

4. Quick Check:

   Overlapping Subproblems = Smaller repeated subproblems [OK]

Hint: Look for repeated smaller problems in the main problem [OK]

Common Mistakes:

• Confusing overlapping subproblems with unique subproblems
• Thinking sorting is necessary for overlapping subproblems
• Assuming recursion alone solves overlapping subproblems

2. Which of the following C++ function signatures correctly represents a memoized Fibonacci function using dynamic programming?

easy

A. void fib(int n);

B. int fib();

C. int fib(int n);

D. int fib(int n, int memo[]);

Solution

1. Step 1: Identify memoization parameters

   Memoization requires an extra data structure (like an array) to store results of subproblems.

2. Step 2: Check function signatures

   int fib(int n, int memo[]); includes an array parameter to store memoized results, which is necessary for memoization.

3. Final Answer:

   int fib(int n, int memo[]); -> Option D

4. Quick Check:

   Memoization needs storage parameter [OK]

Hint: Memoized functions need extra storage parameter [OK]

Common Mistakes:

• Ignoring the memo array parameter
• Using void return type for Fibonacci
• Not passing any parameters for recursion

3. What is the output of the following C++ code snippet?

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

int main() {
  int n = 5;
  int memo[6];
  for(int i = 0; i <= n; i++) memo[i] = -1;
  std::cout << fib(n, memo);
  return 0;
}

medium

A. 13

B. 8

C. 3

D. 5

Solution

1. Step 1: Understand Fibonacci calculation

   fib(5) = fib(4) + fib(3). Using memoization, fib(5) = 8.

2. Step 2: Trace the code execution

   Memo array initialized with -1, so recursive calls compute and store values. fib(5) returns 8.

3. Final Answer:

   8 -> Option B

4. Quick Check:

   fib(5) = 8 [OK]

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

Common Mistakes:

• Confusing fib(5) with fib(6)
• Forgetting zero-based indexing
• Assuming memo array is not initialized

4. Identify the error in the following code snippet implementing memoized Fibonacci:

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

medium

A. The function should return void instead of int.

B. Base cases should return -1 instead of 0 or 1.

C. Memo array should be initialized with -1, not 0.

D. The memo array size is not checked inside the function.

Solution

1. Step 1: Check memoization condition

   The code checks if memo[n] != 0 to decide if value is computed, but 0 is a valid Fibonacci value.

2. Step 2: Correct initialization for memo array

   Memo array should be initialized with a value like -1 to indicate uncomputed states, avoiding confusion with valid 0.

3. Final Answer:

   Memo array should be initialized with -1, not 0. -> Option C

4. Quick Check:

   Use -1 for uninitialized memo values [OK]

Hint: Initialize memo with -1 to distinguish computed from uncomputed [OK]

Common Mistakes:

• Using 0 as default memo value causing wrong cache hits
• Changing base case return values incorrectly
• Ignoring memo array size checks

5. Given the problem of finding the minimum cost path in a grid from top-left to bottom-right, which property justifies using dynamic programming to solve it efficiently?

hard

A. The problem has both overlapping subproblems and optimal substructure.

B. The problem has optimal substructure but no overlapping subproblems.

C. The problem has overlapping subproblems but no optimal substructure.

D. The problem has neither overlapping subproblems nor optimal substructure.

Solution

1. Step 1: Understand minimum cost path problem

   The problem breaks into smaller subproblems (paths to cells) that overlap and solutions combine optimally.

2. Step 2: Identify properties

   It has overlapping subproblems (same cells computed multiple times) and optimal substructure (optimal path uses optimal subpaths).

3. Final Answer:

   The problem has both overlapping subproblems and optimal substructure. -> Option A

4. Quick Check:

   Minimum cost path = Overlapping + Optimal substructure [OK]

Hint: Check if subproblems repeat and combine optimally [OK]

Common Mistakes:

• Thinking only one property applies
• Confusing optimal substructure with greedy choice
• Ignoring repeated subproblems in grid paths