Longest Common Substring in DSA C - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the Longest Common Substring problem?

It is the problem of finding the longest string that appears as a continuous sequence in two given strings.

intermediate

How does the dynamic programming approach help solve the Longest Common Substring problem?

It builds a table where each cell represents the length of the longest common suffix of substrings ending at those positions, allowing us to find the longest common substring efficiently.

beginner

In the DP table for Longest Common Substring, what does a zero value in a cell mean?

It means the characters at the current positions in the two strings do not match, so no common substring ends there.

intermediate

What is the difference between Longest Common Substring and Longest Common Subsequence?

Longest Common Substring requires the matching characters to be continuous, while Longest Common Subsequence allows characters to be non-continuous but in order.

intermediate

What is the time complexity of the dynamic programming solution for Longest Common Substring?

The time complexity is O(m*n), where m and n are the lengths of the two input strings.

What does the DP table cell represent in the Longest Common Substring problem?

A Total number of matching characters so far

B Length of longest common prefix starting at those positions

C Length of longest common suffix ending at those positions

D Length of longest common subsequence so far

Each cell stores the length of the longest common suffix of substrings ending at the current positions in the two strings.

If characters at positions i and j in two strings do not match, what is the DP table value at dp[i][j]?

A 1

B 0

C Maximum of dp[i-1][j] and dp[i][j-1]

D dp[i-1][j-1] + 1

When characters do not match, the longest common suffix ending there is zero.

Which of the following is true about Longest Common Substring?

A It is the same as Longest Common Subsequence

B Characters must appear in order but can be non-continuous

C It finds the longest sequence ignoring order

D Characters must be continuous and appear in both strings

Longest Common Substring requires the substring to be continuous in both strings.

What is the space complexity of the standard DP solution for Longest Common Substring?

A O(m*n)

B O(m+n)

C O(1)

D O(max(m,n))

The DP table requires space proportional to the product of the lengths of the two strings.

Which technique is commonly used to solve the Longest Common Substring problem efficiently?

A Dynamic programming

B Greedy algorithm

C Divide and conquer

D Backtracking

Dynamic programming is used to build solutions for smaller substrings to solve the problem efficiently.

Explain how to use dynamic programming to find the Longest Common Substring between two strings.

Think about building solutions for smaller parts and combining them.

Describe the difference between Longest Common Substring and Longest Common Subsequence.

Focus on continuity and order of characters.

Practice

1. What does the Longest Common Substring problem find between two strings s1 and s2?

easy

A. The longest sequence of characters that appear consecutively in both strings

B. The longest sequence of characters that appear anywhere in both strings, not necessarily consecutively

C. The total number of common characters between the two strings

D. The longest string formed by concatenating both strings

Solution

1. Step 1: Understand the problem definition

   The Longest Common Substring problem looks for the longest sequence of characters that appear in both strings without any breaks (consecutively).

2. Step 2: Differentiate from similar problems

   Unlike Longest Common Subsequence, which allows characters to be non-consecutive, Longest Common Substring requires consecutive matching characters.

3. Final Answer:

   The longest sequence of characters that appear consecutively in both strings -> Option A

4. Quick Check:

   Longest Common Substring = consecutive matching characters [OK]

Hint: Look for consecutive matching characters in both strings [OK]

Common Mistakes:

• Confusing substring with subsequence
• Thinking characters can be non-consecutive
• Counting total common characters instead of longest consecutive

2. Which of the following C code snippets correctly initializes a 2D array dp of size m+1 by n+1 with all zeros for Longest Common Substring?

easy

A. int dp[m+1][n+1] = {0};

B. int dp[m+1][n+1]; memset(dp, 0, sizeof(dp));

C. int dp[m][n]; for(int i=0;i

D. int dp[m+1][n+1]; for(int i=0;i<=m;i++) for(int j=0;j<=n;j++) dp[i][j] = -1;

Solution

1. Step 1: Understand array initialization in C

   To initialize a 2D array with zeros, we can declare it and then use memset to set all bytes to zero.

2. Step 2: Analyze each option

   int dp[m+1][n+1] = {0}; tries to initialize with {0} but this only works for fixed size arrays, not variable sizes. int dp[m+1][n+1]; memset(dp, 0, sizeof(dp)); declares and uses memset correctly. int dp[m][n]; for(int i=0;i

3. Final Answer:

   int dp[m+1][n+1]; memset(dp, 0, sizeof(dp)); -> Option B

4. Quick Check:

   Use memset to zero initialize arrays in C [OK]

Hint: Use memset to zero initialize arrays in C [OK]

Common Mistakes:

• Using {0} for variable size arrays
• Initializing with wrong values like 1 or -1
• Not initializing dp array before use

3. What is the output of the following C code snippet that finds the length of the longest common substring between s1 = "abcde" and s2 = "abfde"?

int longestCommonSubstring(char* s1, char* s2) {
    int m = strlen(s1), n = strlen(s2);
    int dp[m+1][n+1];
    memset(dp, 0, sizeof(dp));
    int maxLen = 0;
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (s1[i-1] == s2[j-1]) {
                dp[i][j] = dp[i-1][j-1] + 1;
                if (dp[i][j] > maxLen) maxLen = dp[i][j];
            } else {
                dp[i][j] = 0;
            }
        }
    }
    return maxLen;
}

int main() {
    printf("%d", longestCommonSubstring("abcde", "abfde"));
    return 0;
}

medium

A. 2

B. 3

C. 4

D. 5

Solution

1. Step 1: Trace matching characters between s1 and s2

   Strings: s1 = "abcde", s2 = "abfde". Matching consecutive characters are "ab" at start and "de" at end. "ab" length = 2, "de" length = 2. The longest common substring length is 2.

2. Step 2: Check dp updates for longest substring

   At i=3, j=3, characters differ ('c' vs 'f'), so dp resets. The longest substring is "ab" or "de" with length 2.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Longest Common Substring length = 2 [OK]

Hint: Check consecutive matching chars, reset on mismatch [OK]

Common Mistakes:

• Counting non-consecutive matches
• Confusing substring length with subsequence length
• Off-by-one errors in indexing

4. The following code attempts to find the longest common substring length but has a bug. What is the bug?

int longestCommonSubstring(char* s1, char* s2) {
    int m = strlen(s1), n = strlen(s2);
    int dp[m][n];
    int maxLen = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (s1[i] == s2[j]) {
                dp[i][j] = dp[i-1][j-1] + 1;
                if (dp[i][j] > maxLen) maxLen = dp[i][j];
            } else {
                dp[i][j] = 0;
            }
        }
    }
    return maxLen;
}

medium

A. dp array is not initialized before use

B. The loop indices should start from 1 instead of 0

C. The maxLen variable is not updated correctly

D. dp array size should be (m+1) x (n+1) to avoid out-of-bound access

Solution

1. Step 1: Analyze dp array size and indexing

   The dp array is declared as dp[m][n], but the code accesses dp[i-1][j-1] which can cause out-of-bound access when i=0 or j=0.

2. Step 2: Correct dp array size and indexing

   To safely access dp[i-1][j-1], dp should be sized (m+1) x (n+1) and loops should run from 1 to m and 1 to n, with dp[0][*] and dp[*][0] initialized to 0.

3. Final Answer:

   dp array size should be (m+1) x (n+1) to avoid out-of-bound access -> Option D

4. Quick Check:

   Use dp size (m+1)x(n+1) for safe indexing [OK]

Hint: Use dp size (m+1)x(n+1) to avoid negative indices [OK]

Common Mistakes:

• Using dp size m x n causing index errors
• Starting loops at 0 but accessing dp[i-1][j-1]
• Not initializing dp array elements

5. Given two strings s1 = "banana" and s2 = "ananas", write a C function to find the longest common substring and return its length. What is the length of the longest common substring?

hard

A. 5

B. 4

C. 3

D. 6

Solution

1. Step 1: Identify common substrings between s1 and s2

   Check substrings of s1 and s2. Common substrings include "ana", "nan", "ana" again, and the longest is "ana" with length 3.

2. Step 2: Confirm no longer substring exists

   No substring longer than 3 exists in both strings consecutively. "anana" is not a substring of "banana" starting at index 1 (it's "anana" in s2 but not in s1 consecutively).

3. Final Answer:

   3 -> Option C

4. Quick Check:

   Longest common substring between "banana" and "ananas" is "ana" length 3 [OK]

Hint: Look for "ana" substring in both strings [OK]

Common Mistakes:

• Confusing substring with subsequence
• Assuming "anana" is common substring
• Stopping at shorter matches like "an"