4.3.1. Case When Characters Match

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 requires us to fill in the table of size m time n, so obviously, every entry in the m times n table, we just have to look at neighbors to fill it up. So, it is a constant time operation. So, m times n entries, we fill it m times n times. So, we have an order n, m n.

In dynamic programming, specifically for problems that involve comparing sequences, we can construct a 2D table where one dimension corresponds to the characters of one sequence and the other dimension corresponds to the characters of the other sequence. Instead of checking every single combination inefficiently, we systematically build the solution using previously computed values in the table, resulting in a time complexity that is polynomial (order m*n) instead of exponential. The 'm' and 'n' denote the lengths of the two sequences being compared.

Imagine you are setting up a grid to find the best route in a maze. Instead of haphazardly trying every single path, you decide to remember where you’ve already been and what paths worked best. Each cell in the grid represents a point you've checked, and by revisiting only the neighboring cells (those directly adjacent), you can find the best way to escape quickly.

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 to drop some letters. So, we have a subsequence not a subword, it 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 deals with finding the longest sequence that can be derived from two sequences by deleting some characters, without changing the order of the remaining characters. This is different from the longest common subword, which requires exact matches without dropping any letters. LCS is particularly useful in areas such as bioinformatics for comparing sequences like DNA or proteins, where slight variations are normal.

Consider two friends who are compiling playlists of music. They each have lists of songs. If they want to find which songs they both like, they can ignore some songs that aren't common to both lists. The longest common subsequence would be the longest list of songs that both of them like, even if they have to overlook some songs that were included in one list and not the other.

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 a good idea to match a 0 to b 0, but now notice that if a 0 is matched to b 2, because it is the subsequence, then anything to the right, say a 1 is matched to something it must be further to the right.

In the LCS problem, we have to decide how to form matches. If the first character of both strings matches, we can include it in our count and continue checking the next characters. However, if they don't match, we need to explore two possibilities: either drop the first character from the first string or the second, but we can't drop both at once because that would disrupt the pairing. This method is recursive and breaks the problem down into smaller subproblems.

Think of a group of friends trying to decide on a movie to watch. If two friends agree on a movie, they will watch that and then find another movie to watch next. But if they can't agree, each friend might start to suggest another movie from their own lists, instead of dropping both suggestions entirely. This ensures that they maximize their chances of finding a movie they can all enjoy together.

So, the subproblem dependency in LCS is a little more complicated than in LCW, LCW we only had this dependency, that is we said that, i j depended i plus 1 j plus 1. But, now we are also dependent on i plus 1 j and i j plus 1. So, we have a three-way dependency as we saw all these values are going to be 0 here.

The computation of the LCS is done using a 2D table where each cell is computed based on the values of adjacent cells in the table. Specifically, if characters match, the value is derived from the diagonally preceding cell plus one. If not, the value for the cell is the maximum from either the top or left adjacent cells. This creates a structure where each cell's value depends on previously computed values, facilitating an efficient calculation of the LCS.

Imagine you’re assembling a puzzle. Each piece's place depends on the pieces that are already correctly placed next to it. If you find that two pieces fit together, you can confidently place them together. If they don’t fit, you must refer back to check adjacent pieces (either above or to the left in your layout) to see which are the best matches, just like referencing your LCS table.

--