Scribd
Upload
153 views19 pages

Recurrence Relation by Master Method

The document discusses recurrence relations and algorithms with recursive structures. It covers two approaches to algorithm design: incremental and divide-and-conquer. Recurrence relations can describe the running time of recursive algorithms using recurrence equations. Common recursive algorithms include Fibonacci, factorial calculation, binary search, and merge sort. The document also discusses methods for solving recurrence relations, including recursion trees and the master method, which can provide tight asymptotic bounds for divide-and-conquer algorithms of a certain form.

Uploaded by

aman
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
153 views19 pages

Recurrence Relation by Master Method

The document discusses recurrence relations and algorithms with recursive structures. It covers two approaches to algorithm design: incremental and divide-and-conquer. Recurrence relations can describe the running time of recursive algorithms using recurrence equations. Common recursive algorithms include Fibonacci, factorial calculation, binary search, and merge sort. The document also discusses methods for solving recurrence relations, including recursion trees and the master method, which can provide tight asymptotic bounds for divide-and-conquer algorithms of a certain form.

Uploaded by

aman
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 19

RECURRENCE RELATION

BY MASTER METHOD
ALGORITHM DESIGNING APPROACH
 There are two approaches which can be used to write
algorithms:

 Incremental (Insertion sort)


 Divide and Conquer (Merge sort, Quick sort)
RECURRENCE
 For large value of input size, recursive algorithms gives
exponential running time complexity.

 When an algorithm contains a recursive call to itself, then


its running time can be described by a recurrence equation or
recurrence.

 Following algorithms are recursive algorithms:


 Fibonacci series calculation
 Factorial calculation
 Binary Search
 Merge Sort
SOLVING RECURRENCES
 Solving recurrences means the asymptotic evaluation of their
efficiency.

 The recurrence can be solved using some mathematical tools


and then bounds (big-O, big-Ω, and big-Θ) on the
performance of the algorithm should be found according to
the corresponding criteria.
COMPOSING RECURRENCES FOR
DIVIDE AND CONQUER ALGORITHMS

A recurrence for the running time of a divide-and-


conquer algorithm is based on the three steps:

 1)Let T(n) be the running time of a problem of


size n. If the problem size is small enough (n≤c)
for some constant c, the straightforward solution
takes constant time, which we write as Θ(1)
COMPOSING RECURRENCES
 2) Suppose that our division of the problem
yields a subproblems, each of which is 1/b size
of the original.

 3)If we take D(n) time to divide the problem


into subproblems and C(n) time to combine the
solutions to the subproblems to the original
problem, we got the recurrence

 (1) if n  c
T ( n)  
aT  n / b   D ( n)  C (n) otherwise
SOLVING RECURRENCES
 Hence, solving recurrences means finding the
asymtotic bounds (big-O, big-Ω, and big-Θ)
for the function T(n).
SOLVING RECURRENCES
 Recursion-tree method converts recursion into a
tree whose nodes represent the “subproblems” and
their costs.
 Substitution method – we guess a bound and then
use mathematical induction to prove our guess.
 Master method provides bounds for recurrences
of the form :
T (n)  aT (n / b)  f (n); a  1, b  1
f (n) is a given function
RECURSION TREE METHOD

A recursion tree is used to present a problem as a


composition of subproblems. It is very suitable to
present any divide-and-conquer algorithm.

 Each node represents the cost of a single


subproblem.

 Usually each level of the tree corresponds to one


step of the recursion.
RECURSION TREE

 We sum the costs within each level of the tree to


obtain a set of per-level costs.

 Then we sum all the per-level costs to determine the


total cost of all levels of the recursion.

 Asa result, we generate a guess that can be then


proven either by substitution method or by master
theorem method.
SOLVING RECURRENCES : THE MASTER THEOREM

 Given:a divide and conquer algorithm


An algorithm that divides the problem of size n
into a subproblems, each of size n/b.

Let the cost of each stage (i.e., the work to


divide the problem + combine solved
subproblems) be described by the function f(n).

 Then, the Master Theorem gives us a some rules


for the algorithm’s running time:
SOLVING RECURRENCES :THE MASTER
METHOD

 Provides the immediate solution for recurrences


of the form

T (n)  aT (n / b)  f (n); a  1, b  1

 f(n) is a given function, which satisfies some


pre-determined conditions.
THE MASTER THEOREM

 if T(n) = aT(n/b) + f(n) then

 
 logb a 
 n  
if f (n)  O n 
logb a 

   0
 
 logb a  c 1

T (n)   n lg n  if f (n)   n  
logb a

  a 1
  b 1
  f ( n) 

if f (n)   n  
logb a 
AND 

 af (n / b)  cf (n) for large n 

EXAMPLE : USING THE MASTER
METHOD

 T(n)
= 9T(n/3) + n
a=9, b=3, f(n) = n

nlog a = nlog 9 = n2
b 3

Since f(n) = n= O(nlog 3 9-


), where  =1,case 1 applies:

  
T (n)   n logb a when f (n)  O n logb a  

Thus the solution is T(n) = (n2)


USING THE MASTER METHOD

 T(n) = 2T(n/2) + n
USING THE MASTER METHOD

 T(n) = 2T(n/2) + n
USING THE MASTER METHOD

 T(n)= 16T(n/4) + n!
 a=16, b=4 f(n) = n!

 Case1: is f(n) = O(nlog 16 - ), where  =1


4

O(nlog 16 - ) = O(n2 - ) = O(n)


4

case 1 not applicable as f(n) will never be


less than O(n)
USING THE MASTER METHOD

 T(n)= 16T(n/4) + n!
 a=16, b=4 f(n) = n!

 Case2: is f(n) =  (nlog 16 ),


4

(nlog 16 ) = (n2 )
4

case 2 not applicable as f(n) will never be


less than (n2 )
USING THE MASTER METHOD

 T(n)= 16T(n/4) + n!
 a=16, b=4 f(n) = n!

 Case3: is f(n) = Ω(nlog 16 + ),


4

Ω (nlog 16 +  ) = Ω (n2+  )
4

Assume  =1 then f(n) = Ω (n3),

case 3 not applicable as f(n) will always be


greater than Ω (n3)

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy