How to Code the Longest Common Subsequence Using Dynamic Programming

The longest common subsequence (LCS) is a fundamental concept in computer science, particularly relevant in fields like bioinformatics and software engineering. In this article, we will discuss how to code the LCS using dynamic programming, providing a clear and comprehensive guide suitable for beginners and experienced programmers.

Introduction to LCS

The Longest Common Subsequence problem is to find the longest sequence that is a subsequence of two or more given sequences. A subsequence is a sequence that appears in the same relative order, but not necessarily contiguous. For example, the strings "ABC" and "ACB" have a LCS of length 3, which is "ABC" (or "ACB").

Using Dynamic Programming to Find the LCS

Dynamic programming is the key technique to efficiently solve the LCS problem. Here's a step-by-step guide on how to implement it:

1. Creating a Table

First, we need a table to store the lengths of LCS of subproblems. This table can be represented by a two-dimensional array (or matrix) of dimensions m x n, where m and n are the lengths of the two input sequences.

Initialize the first row and the first column of the table to 0. These represent the base cases where one of the sequences is empty.

2. Filling the Table

The next step is to fill the table based on the following logic:

tIf the characters in the current positions of both sequences match, then the value in the current cell is one plus the value in the diagonal cell (just above and left of the current cell). tOtherwise, the value in the current cell is the maximum of the value above the current cell and the value to the left of the current cell.

This process is repeated until the entire table is filled. The value in the bottom-right cell of the table represents the length of the LCS.

3. Backtracking to Find the LCS

Starting from the bottom-right cell, trace back through the table using the arrows to construct the LCS. If the characters in the current positions of both sequences match, follow the diagonal arrow. If not, follow the arrow pointing to the greater value (either from above or from the left).

4. Filling the Table in Action

Let's consider an example with two sequences:

First Sequence: ABCDGH
Second Sequence: AEDFHR

With some values filled for clarity:

   |   A   E   D   F   H   R
--|----------------------------
A | 0  0  0  0  0  0  0  0
B | 0  0  0  0  0  0  0  0
C | 0  0  0  0  0  0  0  0
D | 0  0  0  0  1  0  0  0
G | 0  0  0  1  1  0  0  0
H | 0  0  1  1  1  0  1  0

The value in the bottom-right cell is 1, indicating that the LCS has a length of 1. Following the arrows, we can trace back to find the LCS: "A", "D", "H".

Dynamic Programming vs. Recursive Approach

The dynamic programming approach is more efficient than the recursive approach. Here's why:

tReduction in Redundant Calculations: In the recursive approach, the same subproblems are solved multiple times, leading to significant redundancy. The dynamic programming approach avoids this by storing the results of subproblems and reusing them when needed. tTime Complexity: The time complexity of the dynamic programming approach is O(m*n), where m and n are the lengths of the two sequences. The recursive approach has a time complexity of O(2max(m,n)), which is highly inefficient for large sequences.

Pseudo-Code of the LCS Algorithm

# X and Y are the given sequences# m and n are the lengths of X and Y, respectively# LCS is a 2D array of size (m 1) x (n 1)# Initialize the tablefor i from 0 to m:    LCS[i][0]  0for j from 0 to n:    LCS[0][j]  0# Fill the tablefor i from 1 to m:    for j from 1 to n:        if X[i-1]  Y[j-1]:            LCS[i][j]  LCS[i-1][j-1]   1        else:            LCS[i][j]  max(LCS[i-1][j], LCS[i][j-1])# Reconstruct the LCSlcs_sequence  []i  mj  nwhile i gt; 0 and j gt; 0:    if X[i-1]  Y[j-1]:        lcs_(X[i-1])        i - 1        j - 1    elif LCS[i-1][j] gt; LCS[i][j-1]:        i - 1    else:        j - 1# Reverse the sequence to get the correct orderlcs_()

This pseudo-code provides a clear implementation of the LCS algorithm using dynamic programming.

Conclusion

Dynamic programming is a powerful technique for solving optimization problems, especially the LCS problem. By following the steps outlined in this article, you can implement an efficient LCS algorithm that can handle large sequences with ease. Understanding the dynamic programming approach not only helps in solving the LCS problem but also provides valuable insights into solving other similar problems.

Keywords

Dynamic Programming, Longest Common Subsequence, LCS Algorithm