## The Mastery of Computer Programming: Primary Algorithms - Sykalo Eugene 2023

# Longest common subsequence

Dynamic Programming

## Introduction to Longest Common Subsequence

The Longest Common Subsequence (LCS) algorithm is a problem in computer science that involves finding the longest subsequence that is present in two given sequences. A subsequence is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.

LCS is an important algorithm in programming because it has many real-world applications, such as text comparison, DNA sequencing, and image recognition. For example, in text comparison, the LCS algorithm can be used to find the differences between two texts, while in DNA sequencing, it can be used to find the similarities between two genomes.

The LCS problem can be solved using a brute force approach or a dynamic programming approach. The brute force approach involves generating all possible subsequences of the two given sequences and finding the longest common subsequence among them. However, this method is inefficient and has a time complexity of O(2^n), where n is the length of the sequences.

The dynamic programming approach, on the other hand, is more efficient and has a time complexity of O(mn), where m and n are the lengths of the two sequences. This approach involves building a matrix that represents the lengths of the common subsequences of the two input sequences. The matrix is then used to find the LCS.

## Brute Force Approach

The brute force approach to solving the Longest Common Subsequence problem involves generating all possible subsequences of the two given sequences and finding the longest common subsequence among them. This method involves checking every possible combination of elements from both sequences to find the longest common subsequence.

While the brute force approach is conceptually simple, it is inefficient and has a time complexity of O(2^n), where n is the length of the sequences. This is because the number of possible combinations of subsequences grows exponentially with the length of the sequences.

Despite its inefficiency, the brute force approach can be useful for small input sizes or as a starting point for developing more efficient algorithms. It is also useful for understanding the problem and the structure of the solution.

## Dynamic Programming Approach

The dynamic programming approach is a more efficient way to solve the Longest Common Subsequence problem than the brute force approach. This approach involves building a matrix that represents the lengths of the common subsequences of the two input sequences. The matrix is then used to find the LCS.

To build the matrix, we start by initializing the first row and first column of the matrix to 0. We then iterate over each element of the two input sequences, comparing each element to every other element in the other sequence. If the two elements are the same, we add 1 to the value of the cell in the matrix that corresponds to the two elements. Otherwise, we take the maximum value of the adjacent cells in the matrix and set the current cell to that value.

Once the matrix is built, we can find the LCS by starting at the bottom-right cell of the matrix and tracing back to the top-left cell. At each step, we check whether the current cell is equal to the cell to the left, the cell above, or the cell diagonally above and to the left. If the current cell is equal to the cell diagonally above and to the left, we add the corresponding element to the LCS and move to the cell diagonally above and to the left. Otherwise, we move to the adjacent cell with the maximum value.

The dynamic programming approach has a time complexity of O(mn), where m and n are the lengths of the two input sequences. This is significantly faster than the brute force approach, which has a time complexity of O(2^n). Additionally, the dynamic programming approach can be easily modified to find not just the length of the LCS, but also the LCS itself.

## Applications of Longest Common Subsequence

The Longest Common Subsequence (LCS) algorithm has many applications in programming, including text comparison, DNA sequencing, and image recognition.

In text comparison, the LCS algorithm can be used to find the differences between two texts. For example, if you have two versions of a document, you can use the LCS algorithm to find the parts of the document that have been added or removed. This is useful for comparing different versions of a document or for detecting plagiarism.

In DNA sequencing, the LCS algorithm can be used to find the similarities between two genomes. DNA sequences can be incredibly long, and the LCS algorithm can help identify the parts of the sequences that are shared between two genomes. This is useful for understanding the evolution of different species or for identifying genetic disorders.

In image recognition, the LCS algorithm can be used to compare two images and determine their similarity. This can be useful for identifying duplicate images or for detecting changes in an image over time.

Other applications of the LCS algorithm include:

- Spell checking and correction
- Audio signal processing
- Video analysis
- Compression algorithms

## Advanced Topics in Longest Common Subsequence

In addition to the basic Longest Common Subsequence (LCS) algorithm, there are several advanced topics related to LCS that are worth exploring. Some of these topics include:

### Space-Efficient Approach

The space-efficient approach to LCS involves reducing the space complexity of the algorithm by using only two rows of the matrix instead of the entire matrix. This is achieved by storing only the previous row and the current row of the matrix, and discarding the rest of the rows. This approach can be useful for situations where memory is limited.

### Variations of the Algorithm

There are several variations of the LCS algorithm that are used in different contexts. One such variation is the Longest Increasing Subsequence (LIS) algorithm, which is used to find the longest increasing subsequence in a given sequence. Another variation is the Longest Common Substring (LCSu) algorithm, which is used to find the longest common substring between two given strings.

### Optimization Techniques

There are several optimization techniques that can be used to improve the performance of the LCS algorithm. One such technique is memoization, which involves storing the results of previous computations in a lookup table to avoid redundant computations. Another technique is pruning, which involves eliminating parts of the search space that are unlikely to yield a longer common subsequence.