Unit - II

Divide-and-conquer
 Syllabus
• Introduction, divide-and-conquer,
• Binary Search and its algorithm analysis
• Merge sort and its algorithm analysis
• Quick sort and its algorithm analysis
• Strassen's Matrix multiplication
• Finding Maximum and minimum
• Algorithm for finding closest pair
• Convex Hull Problem
 Introduction
• Divide and Conquer is an algorithmic pattern. In
algorithmic methods, the design is to take a
dispute on a huge input, break the input into
minor pieces, decide the problem on each of the
small pieces, and then merge the piecewise
solutions into a global solution. This mechanism
of solving the problem is called the Divide &
Conquer Strategy.
• Divide and Conquer algorithm consists of a
dispute using the following three steps.
1. Divide the original problem into a set of
subproblems.
2. Conquer: Solve every subproblem individually,
recursively.
 Introduction
• Divide / Break
• Conquer / Solve
• Merge / Combine
 Examples : Divide and Conquer Technique

The specific computer algorithms are

based on the Divide & Conquer
approach:
1. Binary Search
2. Sorting (merge sort, quick sort)
3. Strassen's Matrix multiplication
4. Finding Maximum and minimum
5. Algorithm for finding closest pair
6. Convex Hull Problem
 Divide and Conquer Technique

General Method:
The Divide and Conquer Technique splits n inputs
into k subsets , 1< k ≤ n, yielding k subproblems.

These subproblems will be solved and then

combined by using a separate method to get a
solution to a whole problem.

If the subproblems are large, then the Divide and

Conquer Technique will be reapplied.

Often subproblems resulting from a Divide and

Conquer Technique are of the same type as the
original problem.
Control Abstraction/general method for Divide and
Conquer Technique

Algorithm DAndC(p)
{
if Small(p) then return s(p);
else
{
divide p into smaller instances p1,p2,…….,pk, k≥1;
Apply DAndC to each of these subproblems;
return Combine(DAndC(p1), DAndC(p2),……,DAndC(pk));
}
}
 General format
If the size of p is n and the sizes of the k subproblems are
n1,n2,….,nk,then the computing time of DAndC is described by the
recurrence relation

T(n)= g( n) n small
T(n1)+T(n2)+……+T(nk)+f(n) Otherwise
Where T(n) is the time for DAndC on any input of size n and g(n) is
the time to compute the answer directly for small inputs.
The function f(n) is the time for dividing p and combining the
solutions to subproblems.
The Complexity of many divide-and-conquer
algorithms is given by recurrences of the form

c n small
T(n)=
aT(n/b)+f(n) Otherwise

Where a , b and c are known constants.

and n is a power of b (i.e n=ba )
 Binary Search
• Divide / Break
• Conquer / Solve
• Merge / Combine
 Binary Search
1. In Binary Search technique, we search an element
in a sorted array by recursively dividing the
interval in half.
2. Firstly, we take the whole array as an interval.
3. If the Pivot Element (the item to be searched) is
less than the item in the middle of the interval, We
discard the second half of the list and recursively
repeat the process for the first half of the list by
calculating the new middle and last element.
4. If the Pivot Element (the item to be searched) is
greater than the item in the middle of the interval,
we discard the first half of the list and work
recursively on the second half by calculating the
new beginning and middle element.
5. Repeatedly, check until the value is found or
 BINARY SEARCH
• Binary search is implemented using following steps...
• Step 1 - Read the search element from the user.
• Step 2 - Find the middle element in the sorted list.
• Step 3 - Compare the search element with the middle element in the sorted list.
• Step 4 - If both are matched, then display "Given element is found!!!" and terminate the
function.
• Step 5 - If both are not matched, then check whether the search element is smaller or
larger than the middle element.
• Step 6 - If the search element is smaller than middle element, repeat steps 2, 3, 4 and 5 for
the left sublist of the middle element.
• Step 7 - If the search element is larger than middle element, repeat steps 2, 3, 4 and 5 for
the right sublist of the middle element.
• Step 8 - Repeat the same process until we find the search element in the list or until
sublist contains only one element.
• Step 9 - If that element also doesn't match with the search element, then display
"Element is not found in the list!!!" and terminate the function.
 How Binary Search Works?

• The following is our sorted array and let us assume that

we need to search the location of value 31 using binary
search.
• First, we shall determine half of the array by using this
formula –
mid = beginning + ending / 2

• Here it is, 0 + (9 - 0 ) / 2 = 4 (integer value of 4.5). So, 4 is the mid of the array.
 How Binary Search Works?

• We change our low to mid + 1 and find the new mid value again.

low = mid + 1
mid = Big + end / 2

• We conclude that the target value 31 is stored at location 5.

 BINARY SEARCH
Algorithm BinSrch(a, low, high, x)
{
if( low = high)
{
if(x = a[high]) then return high;
else return 0;
}
else
{
mid := (low+high)/2;
if (x = a[mid]) then return mid;
else if(x < a[mid]) then
return BinSrch(a, low, mid-1, x);
else return BinSrch(a, mid+1, high, x);
}
}
 Binary Search - Analysis
1. Input: an array A of size n, already sorted
in the ascending or descending order.
2. Output: analyze to search an element item
in the sorted array of size n.
3. Logic: Let T (n) = number of comparisons
of an item with n elements in a sorted
array.
• Set BEG = 1 and END = n

• Compare the search item with the mid

Binary Search - Analysis
Binary Search - Analysis
 Binary Search - Analysis
• At least there will be only one term left
that's why that term will compare out, and
only one comparison be done that's why
Binary Search - Analysis
 Time Complexity of Binary Search
Successful searches:
best average worst
O(1) O(log n) O( log n)
Merge Sort
 2. Merge Sort
1. Base Case, solve the problem directly
if it is small enough(only one element).

2. Divide the problem into two or more

similar and smaller subproblems.

3. Recursively solve the subproblems.

4. Combine solutions to the subproblems.

 Merge Sort
• Merge sort is yet another sorting algorithm
that falls under the category of Divide and
Conquer technique.
• It is one of the best sorting techniques that
successfully build a recursive algorithm.
Example
 Merge Sort: Idea

Divide into
A FirstPart SecondPart
two halves
Recursively
Recursively sort
sort
FirstPart SecondPart

Merge

A is sorted!
 Merge Sort: Algorithm
MergeSort ( low,high)
// sorts the elements a[low],…,a[high] which reside in the global array
//a[1:n] into ascending order.
// Small(p) is true if there is only one element to sort. In this case the list is
// already sorted.

{ if ( low<high ) then // if there are more than one element

{
mid ← (low+high)/2; Recursive Calls

MergeSort(low,mid);
MergeSort(mid+1, high);
Merge(low, mid, high);
}
}
Merge(A,L,M,H)
Merge Algorithm
{
Split the array into two array a and b;
i=0;j=0;k=0;
for(k=1;k<size[A];k++)
{
If (a[i]<b[j])
{
list[k]=a[i];
i++;
}
else
{
list[k]=b[j];
j++;
}
} list[k] = remaining_elements;
}
 Merge-Sort: Merge Example
hig
low mid h
A: 2
5 3
5 7 28
15 8 30
1 4
6 5 14
10 6

B: 5 5 15 28 30 6 10 14

L: R:
3 5 15 28 6 10 14 22
 Merge-Sort: Merge Example

A: 5 5 15 28 30 6 10 14
B:
3
1 5 15 28 30 6 10 14

k=low

L: R:
3
2 15
3 28
7 30
8 6
1 10
4 14
5 22
6

i=low j=mid+1
 Merge-Sort: Merge Example

A: 5 5 15 28 30 6 10 14
B:
1 2
5 15 28 30 6 10 14

L: R:
3
2 5
3 15
7 28
8 6
1 10
4 14
5 22
6

i j
 Merge-Sort: Merge Example

A: 5 5 15 28 30 6 10 14
B:
1 2 3 28 30
15 6 10 14

L: R:
2 3 7 8 6
1 10
4 14
5 22
6

i j
 Merge-Sort: Merge Example

A: 5 5 15 28 30 6 10 14
B:
1 2 3 4 6 10 14

L: R:
2 3 7 8 6
1 10
4 14
5 22
6

i j
 Merge-Sort: Merge Example

A: 5 5 15 28 30 6 10 14
B:
1 2 3 4 5 6 10 14

L: R:
2 3 7 8 6
1 10
4 14
5 22
6

i j
 Merge-Sort: Merge Example

A: 5 5 15 28 30 6 10 14
B:
1 2 3 4 5 6 10 14

L: R:
2 3 7 8 6
1 10
4 14
5 22
6

i j
 Merge-Sort: Merge Example

A: 5 5 15 28 30 6 10 14
B:
1 2 3 4 5 6 7 14

L: R:
2 3 7 8 6
1 10
4 14
5 22
6

i j
 Merge-Sort: Merge Example

A: 5 5 15 28 30 6 10 14
B:
1 2 3 4 5 6 7 8
14

L: R:
3
2 5
3 15
7 28
8 6
1 10
4 14
5 22
6

i j
 Merge-Sort: Merge Example

A: 5 5 15 28 30 6 10 14
B:
1 2 3 4 5 6 7 8

L: R:
3
2 5
3 15
7 28
8 6
1 10
4 14
5 22
6

i j
A:
5 5 15 28 30 6 10 14

B: 1 2 3 4 5 6 7 8
 Merge-Sort Analysis
n

n/2 n/2

n/4 n/4 n/4 n/4

2 2 2
Analysis of Merge Sort:
• Note stopping condition T(1)=0 because at last, there will be only 1 element
that need to be copied, and there will be no comparison.
• So, we get,
Merge-Sort Time Complexity
If the time for the merging operation is proportional to n, then the
computing time for merge sort is described by the recurrence relation

T(n) c1 n=1, c1 is a constant

=
2T(n/2) + c2n n>1, c2 is a constant

Assume n=2k, then

T(n) =2T(n/2) + c2n
=2(2T(n/4)+c2n/2)+cn
=4T(n/4)+2c2n

…..
…..
=2k T(1)+ kc2n
= c1n+c2nlogn = = O(nlogn)
 Summary
• Merge-Sort
– Most of the work done in combining the
solutions.
– Best case takes o(n log(n)) time
– Average case takes o(n log(n)) time
– Worst case takes o(n log(n)) time
Quick Sort
 3. Quick Sort
• Divide:
• Pick any one of the following as pivot,
– First element
– Last element
– Middle element
– Random element
• Partition the remaining elements into
FirstPart, which contains all elements < pivot
SecondPart, which contains all elements > pivot

• Recursively sort FirstPart and SecondPart.

• Combine: no work is necessary since sorting is done in
place.
pivot divides a into two sublists x and y.

4 2 7 8 1 9 3 6 5
pivo
t

x y
 The whole process

4 2 7 8 1 9 3 6 5

2 1 3 4 7 8 9 6 5

1 2 3 6 5 7 8 9

1 3 5 6 8 9

5 9
Quick Sort Algorithm :
Algorithm QuickSort(low,high)
//Sorts the elements a[low],…..,a[high] which resides
//in the global array a[1:n] into ascending order;
// a[n+1] is considered to be defined and must ≥ all the
// elements in a[1:n].
{
if( low< high ) // if there are more than one element
{ // divide p into two subproblems.
j :=Partition(low,high);
// j is the position of the partitioning element.
QuickSort(low,j-1);
QuickSort(j+1,high);
// There is no need for combining solutions.
}
}
Algorithm Partition(l,h)
{
pivot:= a[l] ; i:=l; j:= h+1;
while( i < j ) do
{
i++;
while( a[ i ] < pivot ) do
i++;
j--;
while( a[ j ] > pivot ) do
j--;

if ( i < j ) then Interchange(i,j ); // interchange ith and

} // jth elements.

Interchange(l, j ); return j; // interchange pivot and jth element.

}
Algorithm interchange (x,y )
{
temp=a[x];
a[x]=a[y];
a[y]=temp;
}
 Best/good Case
n

n/2 n/2

n/4 n/4 n/4 n/4

2 2 2

• Total time: O(nlogn)

• Best case
• Recurrence relation for best case in quick
sort 🡪
• T(n) = 2 T(n/2) + n

• Prove O(nlogn)
 QUICK SORT

•
Time complexity analysis
A worst/bad case

1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
2 3 4 5 6 7 8 9
3 4 5 6 7 8 9
4 5 6 7 8 9
5 6 7 8 9 O(n2)
6 7 8 9
7 8 9
8 9
9
 Worst/bad Case
n cn

n-1 c(n-1)

n-2 c(n-2)

3c
3
Happens only if
• input is sorted 2 2c
• input is reversely sorted 1c
1

Total time:
O(n2)
 T (n) =T(n-1)+n

•T (n-1) is time taken by remaining element

except for pivot element.
•N: the number of comparisons required to
identify the exact position of itself (every
element)
•It means there will be n comparisons if
there are n items.
Solving Recurrence Relation
• K value decreasing by 1 from starting
 Summary
• Quick-Sort
– Most of the work done in partitioning
– Best case takes O(n log(n)) time
– Average case takes O(n log(n)) time
– Worst case takes O(n2) time
Basic Matrix Multiplication
Let A an B two n×n matrices. The product C=AB is also an n×n
matrix.

void matrix_mult (){

for (i = 1; i <= N; i++) {
for (j = 1; j <= N; j++) {
for(k=1; k<=N; k++){
C[i,j]=C[i,j]+A[i,k]+B[k,j];
}
}}

Time complexity of above algorithm is ???

4.Strassen’s Matrix Multiplication
Basic Matrix Multiplication
Let A an B two n×n matrices. The product C=AB is also an n×n
matrix.

void matrix_mult (){

for (i = 1; i <= N; i++) {
for (j = 1; j <= N; j++) {
for(k=1; k<=N; k++){
C[i,j]=C[i,j]+A[i,k]*B[k,j];
}
}}

Time complexity of above algorithm is

T(n)=O(n3)
 How it works ?
• Following is simple Divide and Conquer
method to multiply two square matrices.
1) Divide matrices A and B in 4 sub-matrices
of size N/2 x N/2 as shown in the below
diagram.
2) Calculate following values recursively. ae +
bg, af + bh, ce + dg and cf + dh.
Then, A A B B
c c 11 12 11 12

1 1
C11=A11B11+A12B21
1 2
C12=A11B12+A12B22 c c
C21=A21B11+A22B21 2 2
A A B B
1 2
C22=A21B12+A22B22 21 22 21 22

• Each of these four equations specifies two multiplications of n/2×n/2 matrices

and the addition of their n/2×n/2 products.
• We can derive the following recurrence relation for the time T(n) to multiply
two n×n matrices:

T(n)= c1 if n<=2
8T(n/2)+ c2n2 if n>2

T(n) = O(n3)
Strassen’s method

• Matrix multiplications are more expensive than matrix

additions or subtractions 🡪O(n3)

• Strassen has discovered a way to compute the

multiplication using only 7 multiplications and 18
additions or subtractions.
• His method involves computing 7 n×n matrices
M1,M2,M3,M4,M5,M6, and M7, then cij’s are calculated
using these matrices.
Formulas for Strassen’s Algorithm
M1 = (A11 + A22) * (B11 + B22)
M2 = (A21 + A22) * B11
M3 = A11 * (B12 – B22)
M4 = A22 * (B21 – B11)
M5 = (A11 + A12) * B22
M6 = (A21 – A11) * (B11 + B12)
M7 = (A12 – A22) * (B21 + B22)

C11=M1 + M4 - M5 + M7
C12= M3 + M5
C21= M2 + M4
C22=M1 + M3 - M2 + M6
 C11 C12 A11 A12 B11 B12
= *
C21 C22 A21 A22 B21 B22

M 1 + M 4 - M 5 + M7 M 3 + M5
=
M 2 + M4 M1 + M3 - M2 + M6

The resulting recurrence relation for T(n) is

T(n)= c1 n<=2
7T(n/2) +c2n2 n>2
T(n)= 7kT(1) + c2n2 2 3
1+ 7/4 + (7/4) + (7/4) +……………..+ (7/4)
k-1

..
.

=
7log2n c1 +c2 n2 (7/4)log2n

=
nlog27 + nlog24 ( n log27-log24 )

=2 nlog27 = O(nlog27) ~ O( n2.81)

Maximum Subarray sum
 Largest Sum Contiguous
Subarray
• Given an array arr[] of size N. The task is
to find the sum of the contiguous subarray
within a arr[] with the largest sum.
Example with Trace
• Algorithm
• Algorithm
 Recurrence Relation

• T(n) = 1 l=h
2T(n/2) + n l<h
Analysis
Finding closest pair
 Introduction - finding closest pair
• Given an n points in the plane, and the problem is to
find out the closest pair of points in the array.
• For example, in air-traffic control, you may want to
monitor planes that come too close together, since this
may indicate a possible collision.
• Recall the following formula for distance between two
points p and q.
• Distance between two points:
• P = (Px , Py), q = (qx , qy)
Real-life Applications
» Track the closest pairs in air traffic control
to detect and prevent collision.

» It is easy to come up with Brute Force attack.

Real-life Applications
Brute Force 🡪

By introducing
Real-life Applications
Brute Force attack 🡪

By introducing
Algorithm for finding closest pair
• Given a set of points, find the closest pair
(measured in Euclidean distance).
• a set of n points are given on the 2D
plane. In this problem, we have to find the
pair of points, whose distance is minimum.
• The Brute force solution is O(n2), compute
the distance between each pair and return
the smallest.
• We can calculate the smallest distance in
? time using Divide and Conquer strategy.
• Minimum Criteria
 Algorithm
Input: An array of n points P[]
Output: The smallest distance between two points in the given array.
As a pre-processing step, input array is sorted with x coordinates.
1) Find the middle point in the sorted array, we can take P[n/2] as middle
point.
2) Divide the given array in two halves. The first subarray contains points
from P[0] to P[n/2]. The second subarray contains points from P[n/2+1] to
P[n-1].
3) Recursively find the smallest distances in both subarrays. Let the
distances be dl and dr. Find the minimum d = min(dl, dr). Let the
minimum be d.
4) From above 3 steps, we have an upper bound d of minimum distance.
Now we need to consider the pairs such that one point in pair is from
left half and other is from right half or may be on the mid point itself.
Consider the vertical line passing through P[n/2] and find all points whose
x coordinate is closer than d to the middle vertical line. Build an array
strip[] of all such points.
5) Sort the array strip[] according to y coordinates. It can be optimized to O(n)
by recursively sorting and merging.

6) Find the smallest distance in strip[].

7) Finally return the minimum of d and distance calculated in above step 6

• T(n) = 1 n<=3
2T(n/2) + n n>3
Analysis
Finding Maximum and
minimum
 Finding Maximum and
minimum
• Problem: Analyze the algorithm to find
the maximum and minimum element from
an array.
 Finding Maximum and
minimum
• Problem: Analyze the algorithm to find
the maximum and minimum element from
an array.
 Finding Maximum and
minimum
• Problem: Analyze the algorithm to find
the maximum and minimum element from
an array.
 Finding Maximum and Minimum
• Algorithm straightforward
Finding the maximum and minimum elements in a set of (n) elements
Algorithm straightforward (a, n, max, min)

Input: array (a) with (n) elements

Output: max: max value, min: min value
max = min = a(1)
for i = 2 to n do
begin
if (a(i)>max) then max=a(i)
if (a(i)<min) then min=a(i)
end
End

Complexity
best= average =worst= 2(n-1) comparisons
 56 34 12 1 76 34 23 8 16

56 34 12 1 76 34 23 8 16

56 34 12 1 76 34 23 8 16

Min 34 Min 1 Min 34 23 8 16

Max 56 Max 12 Max 76
Min 23 Min 8
Min 1 Max 23 Max 16
Max 56
Min 8
Max 23

Min 8
Max 76
Min 1
Max 76
 Algorithm
• Algorithm: max_min(x, y)
if y – x ≤ 1 then
return (max(numbers[x], numbers[y]), min((numbers[x], numbers[y]))
else
Mid=(l+h)/2
(max1, min1):= max_min(x, mid)
(max2, min2):= max_min(mid+1,y)
return (max(max1, max2), min(min1, min2))
 Complexity Analysis
1.if size= 1 return current element as both max and min //base condition
2.else if size= 2 one comparison to determine max and min //base condition

3.else /* if size > 2 find mid and call recursive function */

recur for max and min of left half recur for max and min of right half.

one comparison determines to max of the two subarray, update max.

one comparison determines min of the two subarray, update min.

4. finally return or print the min/max in whole array.

Recurrence relation can be written as T(n)=2T(n/2)+2

solving which give you T(n) =(3n/2)-2 which is the exact no. of comparisons
but still the worst time complexity will be T(n)=O(n) and best case time
complexity will be O(1) when you have only one element in array, which will be
candidate for both max and min.
• Let n = is the size of items in an array
• Let T (n) = time required to apply the
algorithm on an array of size n. Here we
divide the terms as T(n/2).
• Similarly, apply the same procedure
recursively on each subproblem

• Recursion will stop, when

• Put the equ.4 into equation3.
Convex Hull Problem
Convex Hull
Convex Hull Problem
Time Complexity for Convex
Hull Problem
 Brute Force Approach
• The brute force method for
determining convex hull is to
construct a line connecting two points
and then verify whether all points are
on the same side or not.
• There are such n(n – 1) /2 lines with n
points, and each line is compared with
the remaining n – 2 points to see if
they fall on the same side.
• As a result, the brute force technique
takes O(n3) time. Can we use divide
 Divide and Conquer Approach
• There exist multiple approaches to solve convex hull
problem. In this article, we will discuss how to solve it
using divide and conquer approach.
1. Sort all of the points by their X coordinates. The tie is
broken by ranking points according to their Y coordinate.
2. Determine two extreme points A and B, where A represents
the leftmost point and B represents the rightmost point. A
and B would be the convex hull’s vertices. Lines AB and BA
should be added to the solution set.
3. Find the point C that is the farthest away from line AB.
4. Calculate the convex hull of the points on the line AC’s
right and left sides. Remove line AB from the original
solution set and replace it with AC and CB.
5. Process the points on the right side of line BA in the same
way.
6. Find the convex hull of the points on the left and right of
the line connecting the two farthest points of that specific
convex hull recursively.
 Algorithm of Convex Hull
Algorithm for finding convex hull
using divide and conquer strategy is
provided below:
 Algorithm of Convex Hull
Algorithm for subroutine FindHull is
described below :
 Finding Complexity
• Dividing points into two halves S1 and
S2 take O(1) time by joining A and B. In
the average case, S1 and S2 contain
half of the points. So, recursively
computing the convex hull of A and B
takes T(n/2) each. Merging of two
convex hulls is done in linear time
O(n), by finding the orthogonally
farthest point. Total running time after
preprocessing the points is given by,
T(n) = 2T(n/2) + n
 Problem: Find the convex hull for a
given set of points using divide and
conquer approach.

• Step 1: According to the algorithm, find left most

and rightmost points from the set P and label them
as A and B. Label all the points on the right of AB as
S1 and all the points on the right of BA as S2.
Make a recursive call to FindHull (S1, A,
B) and FindHull(S2 ,B, A)

• Solution = Solution – { AB } ∪ {AC, CB}= {AC,

CB, BA}
• Label regions X0, X1 and X2 as shown in
above figure
• Make recursive calls: FindHull (X1, A, C) and
Make a recursive call to FindHull (S1, A,
B) and FindHull(S2 ,B, A)
• Solution = Solution – { AB } ∪ {AC, CB}= {AC,
CB, BA}
• Label regions X0, X1 and X2 as shown in
above figure
• Make recursive calls: FindHull (X1, A, C) and
FindHull (X2, C, B)
 Refer this link for Convex Hull
• https://codecrucks.com/convex-hull-using-
divide-and-conquer/#:~:text=The%20conv
ex%20hull%20of%20the,as%20the%20co
nvex%20hull%20problem.