# Master Theorem For Subtract and Conquer Recurrences

Master theorem is used to determine the Big – O upper bound on functions which possess recurrence, i.e which can be broken into sub problems.
Master Theorem For Subtract and Conquer Recurrences:
Let T(n) be a function defined on positive n as shown below: for some constants c, a>0, b>0, k>=0 and function f(n). If f(n) is O(nk), then

1. If a<1 then T(n) = O(nk)
2. If a=1 then T(n) = O(nk+1)
3. if a>1 then T(n) = O(nkan/b)

Proof of above theorem( By substitution method ):

From above function, we have:
T(n) = aT(n-b) + f(n)
T(n-b) = aT(n-2b) + f(n-b)
T(n-2b) = aT(n-3b) + f(n-2b)

Now,
T(n-b) = a2T(n-3b) + af(n-2b) + f(n-b)
T(n) = a3T(n-3b) + a2f(n-2b) + af(n-b) + f(n)
T(n) = Σi=0 to n ai f(n-ib) + constant, where f(n-ib) is O(n-ib)
T(n) = O(nk Σi=0 to n/b ai )

Where,
If a<1 then Σi=0 to n/b ai = O(1), T(n) = O(nk)

If a=1 then Σi=0 to n/b ai = O(n), T(n) = O(nk+1)

If a>1 then Σi=0 to n/b ai = O(an/b), T(n) = O(nkan/b)

Consider the following program for nth fibonacci number:

## C++

 `#include ` `int` `fib(``int` `n) ` `{ ` `   ``if` `(n <= 1) ` `      ``return` `n; ` `   ``return` `fib(n-1) + fib(n-2); ` `} ` `  `  `int` `main () ` `{ ` `  ``int` `n = 9; ` `  ``printf``(``"%d"``, fib(n)); ` `  ``getchar``(); ` `  ``return` `0; ` `} `

## Python3

 `# Python3 code for the above approach ` `def` `fib(n):  ` `    ``if` `(n <``=` `1``):  ` `        ``return` `n  ` `    ``return` `fib(n ``-` `1``) ``+` `fib(n ``-` `2``)  ` ` `  `# Driver code ` `n ``=` `9` `print``(fib(n)) ` ` `  `# This code is contributed ` `# by sahishelangia  `

## Java

 `//Java code for above the approach.  ` `class` `clg  ` `{ ` ` ``static` `int` `fib(``int` `n) ` `{ ` `if` `(n <= ``1``) ` `    ``return` `n; ` `return` `fib(n-``1``) + fib(n-``2``); ` `} ` `// Driver Code ` `public` `static` `void` `main (String[] args) ` `{ ` `int` `n = ``9``; ` `System.out.println( fib(n)); ` `} ` `} ` `// This code is contributed by Mukul Singh.  `

## C#

 `// C# code for above the approach. ` `using` `System; ` `     `  `class` `GFG  ` `{ ` `    ``static` `int` `fib(``int` `n) ` `    ``{ ` `        ``if` `(n <= 1) ` `            ``return` `n; ` `        ``return` `fib(n - 1) + fib(n - 2); ` `    ``} ` `     `  `    ``// Driver Code ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``int` `n = 9; ` `        ``Console.WriteLine(fib(n)); ` `    ``} ` `} ` ` `  `// This code has been contributed  ` `// by Rajput-Ji  `

## PHP

 ` `

Output

```34
```

Time complexity Analysis:
The recursive function can be defined as, T(n) = T(n-1) + T(n-2)

• For Worst Case, Let T(n-1) ≈ T(n-2)
T(n) = 2T(n-1) + c
where,f(n) = O(1)
∴ k=0, a=2, b=1;

T(n) = O(n02n/1)
= O(2n)

• For Best Case, Let T(n-2) ≈ T(n-1)
T(n) = 2T(n-2) + c
where,f(n) = O(1)
∴ k=0, a=2, b=2;

T(n) = O(n02n/2)
= O(2n/2)

More Examples:

• Example-1:
T(n) = 3T(n-1), n>0
= c, n<=0

Sol:a=3, b=1, f(n)=0 so k=0;

Since a>0, T(n) = O(nkan/b)
T(n)= O(n03n/1)
T(n)= 3n

• Example-2:
T(n) = T(n-1) + n(n-1), if n>=2
= 1, if n=1

Sol:a=1, b=1, f(n)=n(n-1) so k=2;

Since a=1, T(n) = O(nk+1)
T(n)= O(n2+1)
T(n)= O(n3)

• Example-3:
T(n) = 2T(n-1) – 1, if n>0
= 1, if n<=0

Sol: This recurrence can't be solved using above method
since function is not of form T(n) = aT(n-b) + f(n)

This article is contributed by Yash Singla. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.