4.. Longest Common Subsequence

So, we can now look at a slightly more general problem than longest common subword in one which is more interesting computationally. So, what if we do not look for an exact match, but we allow a self should drop some letters. So, we have a subsequence not a subword, it is allows us to drop some letters and now, if you want to know, after dropping some letters, what is the longest match we can find.

The longest common subsequence (LCS) problem differs from the longest common subword problem as it allows for letters to be dropped from sequences instead of requiring exact matches. This flexibility enables us to find longer sequences that match after some letters are omitted. For example, when comparing segments from two words, we can achieve a longer matched sequence by selectively dropping letters.

Think of it like finding the common theme in two stories. If Story A includes the word 'hero' and later drops it to include 'brave', while Story B includes 'bravery', you can still identify that both themes relate to courage, even though not all letters align perfectly.

So, before we proceed it useful to look at why the longest common subsequence problem is interesting. So, one of the area is an bio informatics. So, biologist are interested in identifying, how close two species are each other in the genetic sense.

The LCS problem is significant in various fields, one of which is bioinformatics. In genetics, evaluating how closely related two species are can be understood through their DNA sequences. A comparison of DNA sequences using LCS helps to unravel similarities and differences, determining genetic relationships and evolutionary processes efficiently.

Imagine two different species of animals, such as a lion and a tiger. By examining their DNA and looking for the longest common sequences, researchers can see how closely related they are, similar to figuring out if two cousins share common traits in a family tree.

So, let us try understanding inductive structure of this longest common subsequence problem directly, not throw the longest common subword. So, the first thing to note is that if I am looking for this longest common subword between these two, supposing I find that a 0, in fact equal to b 0.

The inductive structure of LCS is based on breaking down the problem into smaller subproblems. If two characters from the sequences match, we can combine them into the LCS and then continue searching for matches in the remaining characters. If they don’t match, we explore two possible scenarios: either excluding the first character from one sequence or excluding it from the other. We continue this process until all possible subsequences have been considered.

Think about it like constructing a puzzle. If the first two pieces fit together, you confidently connect them and look for pieces that extend the connection. However, if they don’t, you must try different placements to see which pieces fit best to complete the picture.

So, as usual let LCS i comma j, stand for the LCS of the problem starting at a i and b j. So, if a i equal b j as we say, LCS of i j is 1 plus LCS of i plus 1 j plus 1.

In LCS, the recursive formula states that if two characters match, we can increment our count by one and check the subsequent characters. This builds upon the concept of dynamic programming where the solution to each subproblem informs the broader solution. We can also track a value, LCS(i, j), which reflects the maximum LCS found at any point during the recursive calls.

This is like climbing a ladder. Each step forward is a successful match of characters—each rung you reach represents adding to your total height (the length of the LCS). If you can’t climb up one rung, you might need to jump to the next and try again, similar to exploring different character combinations.

So, the code for the LCS is little bit simpler then for LCW, because we do not have to keep track of these maximum value and varied occurs, because we only need to find the value at 0 c.

The implementation of LCS involves filling out a grid that stores the results of subproblems. The edges of the grid are initialized to zero because LCS with an empty string is zero. As each cell is filled, whether through matching characters or taking the maximum value from adjacent cells, we build up to the final LCS length, which can be found at the point corresponding to the full length of both sequences.

Imagine you're mapping out a city on a grid. Each intersection represents a decision point for your journey. By marking where you successfully navigated streets (LCS), you can trace back the optimal route you’ve taken, understanding how you reached your final destination (the LCS length).

--