4.3.2. Dynamic Programming

So far at final example before we delegate in this course, let us look at a problem involving documents. So, we have two documents and our goal is to find out how similar they are, right. So, these two documents really variations of the same field. Now, there may be many different scenarios where this problem is interesting.

This chunk introduces the concept of assessing similarity between two documents. The motivation behind this problem lies in various applications such as plagiarism detection or code evolution tracking. The primary goal is to quantify how similar two documents are, which can have important implications in education, journalism, and search engine effectiveness.

Imagine two students submitting assignments. If one student copies from another, measuring document similarity can help a teacher identify this and enforce academic integrity.

Now, there are many different notions that people have come up with. Obviously, it has to do something with the order towards and the choice of letters and so on, but one way of quantifying the distance looking to document is to use what is called the edit distance, namely how many changes do you have to make to transform one document into another document.

Edit distance is a measure that quantifies how many single-character edits (insertions, deletions, substitutions) are needed to convert one document into another. This uniform method of counting changes helps compare text documents objectively.

Consider typing out a message on a phone. If you accidentally type 'hallo' instead of 'hello', you would need to make an edit (substituting 'a' for 'e') to correct it. The edit distance here is 1.

Now, the question that we have as an algorithm problem is how do compute this minimum distance, right. How do you decide what is the best way to edit one document and make it another document.

Determining the minimum edit distance can be complex, as it involves not just brute-force methods but strategic planning of edits. A simple approach would be to consider deleting all characters of one document and then adding the characters of another, but this isn't efficient. Instead, we approach this problem by breaking it down into manageable parts.

Think of rearranging a room efficiently. Instead of moving each piece of furniture one by one, you may map an optimal pathway and strategy to minimize your effort.

So, again we can go to this question is decomposing the problem. So, supposing our first goal is just to make the first character of the two documents say, if they are already the same, we leave and go on.

When comparing documents, we can start by comparing the first characters. If they match, we move to the next character. If they don’t, we have options: transforming one character or inserting a new character. This recursive breakdown allows us to tackle the problem bit by bit.

Imagine you are fixing a broken toy. First, you check if the outer layer is intact. If not, you can either replace that part or add a new piece to hold everything together. By addressing each component, you can effectively repair the toy.

So, now one of the difficulties we face when we do recursion in this manner is that the same sub-problem becomes up for solutions many times.

Recursive methods can lead to recalculating the same values multiple times, which can be inefficient. For instance, when calculating Fibonacci numbers recursively, the same lower Fibonacci numbers are computed repeatedly. This inefficiency drives the need for dynamic programming.

Think of a simple math problem you need to solve multiple times. If you remember the answer the first time you calculated it, you won’t have to redo the work, saving you time — that’s the essence of dynamic programming.

Dynamic programming says do not compute same sub-problems twice. Whenever we solve the problems, if have found f of 4, just look it up, store it somewhere, look it up and make sure that you do not do f 4 again.

Dynamic programming leverages previously calculated results to avoid redundant calculations. By storing solutions to sub-problems (like Fibonacci numbers), we can compute larger problems more efficiently, optimizing the entire process.

Imagine planning a trip. If you already know how long a certain route takes, you don't need to calculate it again if someone asks; you just refer to your previous notes, saving time and effort.

--