### Divide and Conquer Method

In divide and conquer approach, the problem in hand, is divided into smaller sub-problems and then each problem is solved independently. When we keep on dividing the subproblems into even smaller sub-problems, we may eventually reach a stage where no more division is possible. Those "atomic" smallest possible sub-problem (fractions) are solved. The solution of all sub- problems is finally merged in order to obtain the solution of an original problem.

Broadly, we can understand **divide-and-conquer **approach in a three-step process.

### Divide/Break

This step involves breaking the problem into smaller sub-problems. Sub-problems should represent a part of the original problem. This step generally takes a recursive approach to divide the problem until no sub-problem is further divisible. At this stage, sub-problems become atomic in nature but still represent some part of the actual problem.

### Conquer/Solve

This step receives a lot of smaller sub-problems to be solved. Generally, at this level, the problems are considered 'solved' on their own.

### Merge/Combine

When the smaller sub-problems are solved, this stage recursively combines them until they formulate a solution of the original problem. This algorithmic approach works recursively and conquer & merge steps works so close that they appear as one.

**Examples**

** **The following computer algorithms are based on **divide-and-conquer **programming approach

- Merge Sort
- Quick Sort
- Binary Search
- Strassen's Matrix Multiplication
- Closest pair (points)

1. **Binary Search **is a searching algorithm. In each step, the algorithm compares the input element x with the value of the middle element in array. If the values match, return the index of Otherwise, if x is less than the middle element, then the algorithm recurs for left side of middle element, else recurs for right side of middle element.

**2. Quick Sort **is a sorting algorithm. The algorithm picks a pivot element, rearranges the array elements in such a way that all elements smaller than the picked pivot element move to left side of pivot, and all greater elements move to right side. Finally, the algorithm recursively sorts the subarrays on left and right of pivot element.

**3. Merge Sort **is also a sorting algorithm. The algorithm divides the array in two halves, recursively sorts them and finally merges the two sorted halves.

**4. Closest Pair of Points **The problem is to find the closest pair of points in a set of points in x-y The problem can be solved in **O(n^2) **time by calculating distances of every pair of points and comparing the distances to find the minimum. The Divide and Conquer algorithm solves the problem in **O(nLogn) **time.

**5. Strassen’s Algorithm **is an efficient algorithm to multiply two matrices. A simple method to multiply two matrices need 3 nested loops and is **O(n^3). **Strassen’s algorithm multiplies two matrices in **O(n^2.8974) **

**6. Cooley–Tukey Fast Fourier Transform (FFT) algorithm **is the most common algorithm for It is a divide and conquer algorithm which works in **O(nlogn) **time.

**7. Karatsuba algorithm for fast multiplication**** **it does multiplication of two *n*-digit numbers in at most single-digit multiplications in general (and exactly when *n *is a power of 2). It is therefore faster than the classical algorithm, which requires *n*^{2} single-digit products. If *n *= 2^{10} = 1024, in particular, the exact counts are 3^{10} = 59,049 and (2^{10})^{2} = 1,048,576, respectively.

There are various ways available to solve any computer problem, but the mentioned are a good example of divide and conquer approach.