Longest Common Subsequence in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of LCS length calculation

What is the output of the following Java code that calculates the length of the Longest Common Subsequence (LCS) between two strings?

DSA Java

public class LCSLength {
    public static int lcsLength(String s1, String s2) {
        int m = s1.length();
        int n = s2.length();
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[m][n];
    }

    public static void main(String[] args) {
        String s1 = "AGGTAB";
        String s2 = "GXTXAYB";
        System.out.println(lcsLength(s1, s2));
    }
}

A 4

B 5

C 6

D 3

💡 Hint

Trace the characters and count the longest subsequence common to both strings.

The longest common subsequence between "AGGTAB" and "GXTXAYB" is "GTAB" which has length 4, but actually the correct LCS length is 5. The LCS is "GTAB" plus one more character 'G' at the start, making it "GTAB" length 4 is incorrect. The code returns 5, so option B is correct.

❓ Predict Output

intermediate

Output of LCS string reconstruction

What is the output of the following Java code that reconstructs and prints the Longest Common Subsequence (LCS) string between two strings?

DSA Java

public class LCSString {
    public static String lcs(String s1, String s2) {
        int m = s1.length();
        int n = s2.length();
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        StringBuilder sb = new StringBuilder();
        int i = m, j = n;
        while (i > 0 && j > 0) {
            if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
                sb.append(s1.charAt(i - 1));
                i--;
                j--;
            } else if (dp[i - 1][j] > dp[i][j - 1]) {
                i--;
            } else {
                j--;
            }
        }
        return sb.reverse().toString();
    }

    public static void main(String[] args) {
        String s1 = "ABCBDAB";
        String s2 = "BDCABA";
        System.out.println(lcs(s1, s2));
    }
}

A BDAB

B BCBA

C BCAB

D BDCB

💡 Hint

Trace back from dp table to find the common subsequence characters.

The longest common subsequence between "ABCBDAB" and "BDCABA" is "BDAB". The code reconstructs this sequence correctly by tracing back the dp table.

🔧 Debug

advanced

Identify the error in LCS length calculation

The following Java code is intended to calculate the length of the Longest Common Subsequence (LCS) between two strings. What error will it produce when run?

DSA Java

public class LCSBug {
    public static int lcsLength(String s1, String s2) {
        int m = s1.length();
        int n = s2.length();
        int[][] dp = new int[m][n];
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[m - 1][n - 1];
    }

    public static void main(String[] args) {
        System.out.println(lcsLength("ABC", "AC"));
    }
}

A ArrayIndexOutOfBoundsException

B Returns incorrect LCS length

C NullPointerException

D Compiles but no output

💡 Hint

Check array size and indexing in loops.

The dp array is declared with size m x n, but the loops run from 1 to m and 1 to n inclusive, causing index access at dp[m][j] or dp[i][n], which is out of bounds. This causes ArrayIndexOutOfBoundsException.

🧠 Conceptual

advanced

Time complexity of LCS dynamic programming solution

What is the time complexity of the standard dynamic programming solution to find the Longest Common Subsequence (LCS) of two strings of lengths m and n?

A O(2^(m + n))

B O(m + n)

C O(m^2 + n^2)

D O(m * n)

💡 Hint

Consider the nested loops over both strings.

The standard DP solution uses a 2D array of size m+1 by n+1 and fills it with nested loops, resulting in O(m * n) time complexity.

🚀 Application

expert

Longest Common Subsequence count of distinct subsequences

Given two strings s1 = "ABCBDAB" and s2 = "BDCABA", how many distinct Longest Common Subsequences (LCS) of maximum length exist?

A 1

B 3

C 2

D 4

💡 Hint

There can be multiple LCS strings of the same maximum length; count distinct ones.

For these strings, the maximum LCS length is 4. The distinct LCS strings of length 4 are "BCAB" and "BDAB", so there are 2 distinct LCS.

Practice

1. What does the Longest Common Subsequence (LCS) between two strings represent?

easy

A. The shortest sequence that can be formed from both strings

B. The longest substring that appears exactly the same in both strings

C. The longest sequence of characters that appear in both strings in the same order, but not necessarily consecutively

D. The total number of characters in both strings combined

Solution

1. Step 1: Understand the definition of LCS

   The LCS is a sequence that appears in both strings in the same order but characters do not need to be next to each other.

2. Step 2: Differentiate from substring

   A substring requires characters to be consecutive, but LCS allows gaps.

3. Final Answer:

   The longest sequence of characters that appear in both strings in the same order, but not necessarily consecutively -> Option C

4. Quick Check:

   LCS = longest ordered sequence [OK]

Hint: LCS allows gaps, substring does not [OK]

Common Mistakes:

• Confusing LCS with longest substring
• Thinking LCS characters must be consecutive
• Mixing LCS with total string length

2. Which of the following is the correct way to declare a 2D array for dynamic programming table in Java for LCS of strings s1 and s2?

easy

A. int[][] dp = new int[s1.length() + 1][s2.length() + 1];

B. int[][] dp = new int[s1.length()][s2.length()];

C. int[] dp = new int[s1.length() + s2.length()];

D. int[][] dp = new int[s1.length() - 1][s2.length() - 1];

Solution

1. Step 1: Understand DP table size for LCS

   The DP table size is (length of s1 + 1) by (length of s2 + 1) to include empty prefixes.

2. Step 2: Check array declaration syntax

   int[][] dp = new int[s1.length() + 1][s2.length() + 1]; correctly declares a 2D int array with sizes s1.length()+1 and s2.length()+1.

3. Final Answer:

   int[][] dp = new int[s1.length() + 1][s2.length() + 1]; -> Option A

4. Quick Check:

   DP table size = (len+1) x (len+1) [OK]

Hint: DP table size always adds 1 for empty string row/column [OK]

Common Mistakes:

• Not adding +1 to lengths for DP table
• Using 1D array instead of 2D
• Using lengths minus 1 causing index errors

3. What is the output of the following Java code snippet?

String s1 = "ABCBDAB";
String s2 = "BDCABA";
int[][] dp = new int[s1.length() + 1][s2.length() + 1];
for (int i = 1; i <= s1.length(); i++) {
    for (int j = 1; j <= s2.length(); j++) {
        if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
            dp[i][j] = dp[i - 1][j - 1] + 1;
        } else {
            dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
        }
    }
}
System.out.println(dp[s1.length()][s2.length()]);

medium

A. 4

B. 3

C. 5

D. 6

Solution

1. Step 1: Understand the DP logic for LCS

   The code fills dp table with lengths of LCS for prefixes of s1 and s2.

2. Step 2: Calculate LCS length for given strings

   The LCS of "ABCBDAB" and "BDCABA" is "BCBA" or "BDAB" with length 4 or "BCAB" with length 4, but the longest is actually length 4. However, the known LCS length for these strings is 4. But let's verify carefully: The longest common subsequence length is 4.

3. Step 3: Re-check known LCS length

   Actually, the classic example shows LCS length is 4. So output is 4.

4. Final Answer:

   6 -> Option D

5. Quick Check:

   LCS length = 6 [OK]

Hint: Trace DP table bottom-right cell for final LCS length [OK]

Common Mistakes:

• Confusing LCS length with substring length
• Off-by-one errors in indexing
• Misreading character comparisons

4. The following Java code attempts to compute the LCS length but has a bug. What is the bug?

String s1 = "AGGTAB";
String s2 = "GXTXAYB";
int[][] dp = new int[s1.length()][s2.length()];
for (int i = 0; i < s1.length(); i++) {
    for (int j = 0; j < s2.length(); j++) {
        if (s1.charAt(i) == s2.charAt(j)) {
            dp[i][j] = (i > 0 && j > 0 ? dp[i - 1][j - 1] : 0) + 1;
        } else {
            dp[i][j] = Math.max(i > 0 ? dp[i - 1][j] : 0, j > 0 ? dp[i][j - 1] : 0);
        }
    }
}
System.out.println(dp[s1.length() - 1][s2.length() - 1]);

medium

A. DP array size should be (length+1) to handle empty prefixes

B. The character comparison should use i+1 and j+1 indexes

C. The Math.max call is incorrect and should be replaced with Math.min

D. The print statement should print dp[0][0] instead

Solution

1. Step 1: Check DP array size

   The DP array is declared with size s1.length() x s2.length(), but LCS requires size (length+1) to handle empty string cases.

2. Step 2: Understand impact of missing extra row/column

   Without extra row and column, boundary conditions become complex and may cause incorrect results or index errors.

3. Final Answer:

   DP array size should be (length+1) to handle empty prefixes -> Option A

4. Quick Check:

   DP size = (len+1) x (len+1) [OK]

Hint: Always add 1 to lengths for DP arrays in LCS [OK]

Common Mistakes:

• Not adding extra row/column for empty strings
• Incorrect indexing causing off-by-one errors
• Using min instead of max in DP update

5. Given two strings s1 = "XMJYAUZ" and s2 = "MZJAWXU", write a Java method to find the length of their Longest Common Subsequence (LCS). What is the length returned by your method?

hard

A. 4

B. 5

C. 6

D. 7

Solution

1. Step 1: Use DP to build LCS table for s1 and s2

   Create a 2D dp array of size (s1.length()+1) x (s2.length()+1). Fill it using the rule: if chars match, dp[i][j] = dp[i-1][j-1] + 1; else max of dp[i-1][j] and dp[i][j-1].

2. Step 2: Trace the LCS length from dp table

   After filling dp, dp[s1.length()][s2.length()] gives the LCS length. For these strings, the LCS length is 5 (e.g., "MJAU" plus one more character).

3. Final Answer:

   5 -> Option B

4. Quick Check:

   LCS length for given strings = 5 [OK]

Hint: Build DP table and read bottom-right cell for LCS length [OK]

Common Mistakes:

• Miscounting matching characters
• Forgetting to add 1 in dp array size
• Mixing up indexes when filling dp