## TL;DR

In this short article I’m do the efforts to define the difference/similarities between dynamic programing and divide and also conquer approaches based upon two examples:**binary search**and

**minimum edit distance**(Levenshtein distance).

You are watching: Dynamic programming vs divide and conquer

## The Problem

When i **started to discover algorithms** the was difficult for me to understand the main idea the dynamic programming (**DP**) and also how it is various from divide-and-conquer (**DC**) approach. Once it gets to compare those two paradigms commonly Fibonacci duty comes to the rescue as an excellent example. Yet when we’re trying to resolve the **same** problem using both DP and also DC philosophies to describe each of them, the feels for me like we might **lose an important detail** that might assist to capture the difference faster. And also these information tells us that each method serves finest for **different** types of problems.

I’m still in the procedure of knowledge DP and also DC difference and I can not say the I’ve fully grasped the principles so far. Yet I hope this short article will shed some extra light and aid you to do another step of learning such an important algorithm paradigms as dynamic programming and also divide-and-conquer.

## Dynamic Programming and Divide-and-Conquer Similarities

As I view it for now I can say that **dynamic programming is an extension of divide and also conquer paradigm**.

I would **not** law them as something completely different. Due to the fact that **they** **both work by recursively breaking under a difficulty into two or more sub-problems** that the exact same or connected type, till these become straightforward enough come be addressed directly. The services to the sub-problems space then combined to offer a solution to the original problem.

So why do we tho have different paradigm names then and why I called dynamic programming one extension. The is due to the fact that dynamic programming method may be applied to the problem **only if the problem has certain** **restrictions or prerequisites**. And also after the dynamic programming **extends** divide and also conquer strategy with **memoization** or **tabulation** technique.

Let’s go step by step…

## Dynamic Programming Prerequisites/Restrictions

As we’ve just discovered there are two key attributes that divide and conquer trouble must have in order because that dynamic programming to it is in applicable:

Once these two conditions are met we can say the this divide and also conquer trouble may be fixed using dynamic programming approach.

**Dynamic Programming extension for Divide and Conquer**

Dynamic programming strategy extends divide and conquer strategy with two approaches (**memoization** and also **tabulation**) that both have actually a purpose of storing and re-using sub-problems options that may drastically improve performance. For example naive recursive implementation the Fibonacci role has time complexity of O(2^n) whereby DP equipment doing the exact same with only O(n) time.

**Memoization (top-down cache filling) **refers come the an approach of caching and also reusing formerly computed results. The memoized fib duty would hence look like this:

memFib(n) if (mem**Tabulation (bottom-up cache filling) **is similar but concentrates on filling the entries the the cache. Computing the worths in the cache is simplest done iteratively. The tabulation version of fib would certainly look favor this:

tabFib(n) mem<0> = 0 mem<1> = 1 for ns = 2...n mem* = mem + mem*

*The key idea you have to grasp here is that since our divide and also conquer difficulty has overlapping sub-problems the caching that sub-problem solutions becomes feasible and thus memoization/tabulation action up onto the scene.*

*So What the Difference in between DP and also DC after All*

*Since we’re now acquainted with DP prerequisites and its methodologies we’re prepared to placed all the was mentioned over into one picture.*

Let’s walk and shot to settle some difficulties using DP and DC approaches to make this illustration much more clear.

## Divide and Conquer Example: Binary Search

Binary search algorithm, additionally known as half-interval search, is a find algorithm the finds the place of a target worth within a sorted array. Binary find compares the target value to the middle aspect of the array; if they are unequal, the half in i beg your pardon the target can not lie is eliminated and also the search continues on the remaining fifty percent until the target value is found. If the find ends v the remaining half being empty, the target is no in the array.

**Example**

Here is a visualization of the binary search algorithm whereby 4 is the target value.

You may clearly see here a divide and also conquer principle of solving the problem. We’re iteratively breaking the original range into sub-arrays and trying to uncover required element in there.

Can we apply dynamic programming to it? **No.** it is due to the fact that **there are no overlapping sub-problems**. Every time we split the variety into fully independent parts. And also according come divide and conquer prerequisites/restrictions the sub-problems **must be** overlapped somehow.

Normally every time you draw a decision tree and it is actually a **tree** (and **not** a decision **graph**) that would typical that girlfriend don’t have overlapping sub-problems and this is no dynamic programming problem.

**The Code**

Here girlfriend may find complete source code the binary search function with check cases and explanations.

function binarySearch(sortedArray, seekElement) let startIndex = 0; let endIndex = sortedArray.length - 1; if (startIndex const middleIndex = startIndex + Math.floor((endIndex - startIndex) / 2); // If we've discovered the aspect just return its position. If (sortedArray

## Dynamic Programming Example: Minimum edit Distance

Normally once it involves dynamic programming examples the Fibonacci number algorithm is gift taken by default. However let’s take it a tiny bit more complex algorithm to have actually some kind of range that should help us to master the concept.Minimum modify Distance (or Levenshtein Distance) is a wire metric for measuring the difference in between two sequences. Informally, the Levenshtein distance between two words is the minimum number of single-character edits (*insertions, deletions or substitutions*) forced to adjust one word into the other.

**Example**

For** **example, the Levenshtein distance in between “kitten” and “sitting” is 3, since the following three edits change one into the other, and also there is no means to perform it v fewer than 3 edits:

**k**itten →

**s**itten (substitution of “s” for “k”)sitt

**e**n → sitt

**i**n (substitution the “i” because that “e”)sittin → sittin

**g**(insertion that “g” in ~ the end).

**Applications**

This has a wide selection of applications, for instance, order checkers, correction solution for optical personality recognition, fuzzy wire searching, and also software to help natural language translation based on translation memory.

**Mathematical Definition**

Mathematically, the Levenshtein distance between two strings a, b (of length |a| and also |b| respectively) is provided by duty lev(|a|, |b|) where

Note the the first element in the minimum synchronizes to **deletion** (from a to b), the second to **insertion** and the third to **match** **or mismatch**, depending on whether the respective symbols space the same.

**Explanation**

Ok, let’s try to number out what the formula is talking about. Let’s take a simple example of detect minimum modify distance between strings **ME** and **MY**. Intuitively you already know the minimum modify distance right here is **1** operation and this procedure is “*replace **E** v *** Y**”. But let’s shot to formalize it in a type of the algorithm in bespeak to have the ability to do more complicated examples prefer transforming

**Saturday**right into

**Sunday**.

To apply the formula to *M**E**→M*** Y** revolution we require to know minimum edit ranges of

*ME→M*,

*M→MY*and

*M→M*transformations in prior. Then we will have to pick the minimum one and include +1 procedure to transform last letters

*E→Y*.

So we can already see right here a recursive nature that the solution: minimum modify distance that *ME→MY* transformation is gift calculated based upon three previously feasible transformations. For this reason we may say the this is **divide and conquer algorithm**.

To describe this more let’s draw the adhering to matrix.

**Cell (0,1)** contains red number 1. It method that we need 1 operation to transform **M** to **empty string**: delete **M**. This is why this number is red.

**Cell (0,2)** contains red number 2. It means that we require 2 operations to change **ME** to **empty string**: delete **E**, delete **M**.

**Cell (1,0)** includes green number 1. It means that we need 1 operation to transform empty string to **M**: insert **M**. This is why this number is green.

**Cell (2,0)** consists of green number 2. It means that we require 2 operations come transform north string come **MY**: insert **Y**, insert **M**.

**Cell (1,1) **contains number 0. It way that it prices nothing to transform **M** to **M**.

**Cell (1,2)** consists of red number 1. It method that we need 1 procedure to change **ME** come **M**: delete **E**.

And for this reason on…

This looks simple for such small matrix together ours (it is only 3x3). Yet how we could calculate every those numbers because that bigger matrices (let’s to speak 9x7 one, because that Saturday*→*Sunday transformation)?

The good news is that according come the formula you only require three adjacent cells (i-1,j), (i-1,j-1), and (i,j-1) to calculate the number for present cell (i,j) . Every we have to do is to find the minimum of those 3 cells and also then include +1 in situation if us have various letters in i-s row and also j-s column

So once again friend may plainly see the recursive nature that the problem.

First of every this is **not** a decision **tree**. The is a decision **graph**. You may see a number of **overlapping subproblems** on the photo that are significant with red. Also there is no method to minimize the number of operations and make it much less then a minimum that those three nearby cells native the formula.

Also friend may notification that every cell number in the matrix is being calculated based on previous ones. Therefore the **tabulation** method (filling the cache in bottom-up direction) is being used here. You’ll see it in code instance below.

Applying this ethics further we may solve more complicated cases prefer with Saturday*→*Sunday transformation.

**The Code**

Here friend may find complete source code that minimum modify distance role with test cases and explanations.

function levenshteinDistance(a, b) const distanceMatrix = Array(b.length + 1) .fill(null) .map( () => Array(a.length + 1).fill(null) ); because that (let i = 0; i distanceMatrix<0>* = i; because that (let j = 0; j distanceMatrix <0> = j; } for (let j = 1; j because that (let ns = 1; ns const indicator = a*

*=== b ? 0 : 1; distanceMatrix*

*= Math.min( distanceMatrix**+ 1, // deletion distanceMatrix**+ 1, // insertion distanceMatrix**+ indicator, // substitution ); } } return distanceMatrix*;} *Conclusion*

*Conclusion*

*In this short article we have compared two algorithmic ideologies such together dynamic programming and divide-and-conquer. We’ve found out that dynamic programing is based upon divide and also conquer principle and also may be applied only if the difficulty has overlapping sub-problems and optimal substructure (like in Levenshtein street case). Dynamic programming climate is utilizing memoization or tabulation technique to store services of overlapping sub-problems for later usage.*

See more: The Fishing Club 3D Fish Locations, The Fishing Club 3D

See more: The Fishing Club 3D Fish Locations, The Fishing Club 3D

I expect this article hasn’t brought you more confusion yet rather burned some light on this two essential algorithmic concepts! :)

You may find an ext examples that divide and also conquer and also dynamic programming problems with explanations, comments and test situations in JavaScript Algorithms and Data structures repository.