4.3.1. Fibonacci Numbers Example

So, this is really an inefficient way to calculate it whereas, I just do it for in since here, I get 1 1 2 3 5 8 13 21 and I find that the seventh Fibonacci number is actually you sequence not use that it, right. So, there is intuitively a very fast way to do this. The recurrence is respected, but if I do it recursively, I end up solving a lot of problems again and again.

The Fibonacci numbers are a special numerical sequence, where each number is the sum of the two preceding ones, starting from 0 and 1. This relationship can create recursive calculations, as each Fibonacci number depends on its two predecessors. For instance, to find the seventh Fibonacci number, you would need to calculate the sixth and fifth numbers first. However, using a direct recursive approach can lead to inefficiencies, as the same Fibonacci numbers will be calculated multiple times, for example, both the fifth and sixth Fibonacci numbers would require calculating the fourth Fibonacci number multiple times.

Think of Fibonacci numbers like a family tree. If you want to find out how many generations it takes to reach a great-grandchild, you have to count all the children and grandchildren first. However, if you count them over and over for different children, the counting becomes inefficient, similar to recalculating Fibonacci numbers unnecessarily.

So, if I do it recursively, I end up solving a lot of problems again and again. So, how do we get around it and this is what we call dynamic program. Dynamic programming says do not compute same sub-problems twice.

Dynamic programming is an optimization technique that helps to solve complex problems by breaking them down into simpler sub-problems. In the context of Fibonacci numbers, instead of calculating each number from scratch every time, you can store each computed Fibonacci number in a list or array. This allows you to reuse those values whenever needed, rather than recalculating them, thus saving time and computational resources.

Imagine you are baking cookies and need to know how to divide your dough into different shapes. Instead of making each shape from scratch every time, you can create a shape template. Whenever you need that shape again, you just reference your template rather than creating it all over again. This is similar to using stored Fibonacci values.

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.

When applying dynamic programming to Fibonacci calculations, you store previously computed results. For example, once you compute the fourth Fibonacci number, you can keep it in memory. When asked for the sixth Fibonacci number again, you just use the fourth number from memory instead of calculating it afresh. This leads to a significantly lower number of calculations and faster results.

Think about memorizing a favorite recipe. Once you’ve tried it and remember the steps, you won’t need to reread the entire recipe each time you bake. Instead, you just recall the steps you learned when you first made the dish. This is like remembering computed Fibonacci values.

The problem is that when you apply the recursion directly, so if try to compute the seventh Fibonacci number for example, it will say for this I need to compute f 6 plus f 5.

The concept of recursively calculating the Fibonacci numbers can parallel finding similarities between documents. Here, recursion refers to a method of solving problems by breaking them down into smaller, similar sub-problems. Just as we recursively find Fibonacci numbers, we can recursively identify similarities in documents. Each document can be viewed as requiring comparisons with increasingly smaller segments or past comparisons, which can lead to redundancy without proper storage strategies.

Imagine trying to find how different two versions of an article are. If you compare every paragraph from one version directly with every paragraph from the other, you’ll find yourself repeating comparisons. Instead, you could summarize similarities for sections and then compare those summaries, saving a lot of time and effort.

--