4.5. Filling the LCS Table

So, we have seen earlier that if we just look blindly at every position and try to scan the word starting that position, we get something which is an order m, n square. now, this solution when require as to fill in the table of size m time n, so obviously, every entries in the m times n table, we just have to look at a neighbors to fill it up. So, it is a constant time operation. So, m times n entries, we fill it m times n times.

The Longest Common Subsequence (LCS) problem involves finding the longest sequence that can appear in both strings in the same order but not necessarily consecutively. To fill the LCS table, we consider all entries m by n, meaning we compare every character of one string with every character of another. The operation required to fill each entry is constant time since we only compare neighboring values, leading to a time complexity of O(m * n).

Imagine you are trying to find all common words between two books in a library. Instead of reading both books line by line (which takes a long time), you can just scan for words that are in both and match them. This way, you are efficiently finding common phrases quickly, similar to how we fill out the LCS table.

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.

In the LCS problem, we relax the condition of requiring exact matches by allowing for the deletion of characters (self-drop). This allows for a broader search for common sequences, meaning a longer subsequence can be derived from the original strings by dropping some letters. This introduces new matches that would not have been possible in a strict subword match, thus potentially increasing the length of the common subsequence.

Think of it as playing a word game where you can form new words by leaving out certain letters. For example, if you drop 'o' from 'word', you can match it with 'ward'. This flexibility can lead to discovering longer common sequences that may not be immediately visible.

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.

LCS has significant applications in various fields, particularly in bioinformatics, where researchers use it to analyze genetic sequences. By identifying common subsequences in the DNA of two organisms, scientists can infer how closely related they are genetically. This understanding can lead to discoveries about evolution, disease mechanisms, and potential treatments.

Consider two family trees being traced. By looking for common ancestors (like looking for common letters in words), genealogists can determine how closely related two families are over generations, paralleling how LCS identifies relationships in genetic sequences.

So, one might argue that, this is not the way, I want to go, supposing a 0, in fact, should be match to b 2, that would be the best solution. So, it is not good idea match a 0 to be b 0, but now notice that if a 0 is match to b 2, because it is the subsequence, then anything to the write, say a 1 is match to something it must be further to the right.

The inductive approach to solving the LCS involves analyzing the substrings formed once a match is found or determining which letters to keep or drop. If the first character of both strings matches, it is safe to include it in the LCS and continue the search. However, if they do not match, a decision is made to either drop one character or include it in the search for matches to maximize the subsequence length, forming new subproblems.

Consider assembling a puzzle where you've just found a piece that fits. If you put it in place, you can move ahead confidently, but if it seems like it doesn't fit, you might consider keeping it aside to see if you can find other pieces to match instead. This back-and-forth decision-making is akin to the process of dynamic programming in solving the LCS.

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.

The dynamic programming approach starts filling up entries in a grid. LCS[i][j] indicates the length of the longest common subsequence from strings a and b starting at positions i and j. If the characters are the same (a[i] == b[j]), it counts as 1 plus whatever LCS can be derived from the next characters. If not, we explore two possibilities: skipping one character from string a or one from string b to find the maximum LCS.

Imagine building a staircase where each step represents a matching character. Each time you match a character, you step up, and if you encounter a mismatch, you have to decide whether to skip a step or choose another path to find the next step you can match, just as we build up the LCS using the grid.

--