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(n^k), then
1. If a<1 then T(n) = O(n^k) 
2. If a=1 then T(n) = O(n^k+1) 
3. if a>1 then T(n) = O(n^ka^n/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) = a²T(n-3b) + af(n-2b) + f(n-b) 
T(n) = a³T(n-3b) + a²f(n-2b) + af(n-b) + f(n) 
T(n) = ?^{i=0 to n} aⁱ f(n-ib) + constant, where f(n-ib) is O(n-ib) 
T(n) = O(n^k ?^{i=0 to n/b} aⁱ )

Where, 
If a<1 then ?^{i=0 to n/b} aⁱ = O(1), T(n) = O(n^k)
If a=1 then ?^{i=0 to n/b} aⁱ = O(n), T(n) = O(n^k+1) 
If a>1 then ?^{i=0 to n/b} aⁱ = O(a^n/b), T(n) = O(n^ka^n/b)
Consider the following program for nth fibonacci number: 

C++

#include<stdio.h>
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

<?php
// PHP code for the above approach
function fib($n)
{
    if ($n <= 1)
        return $n;
    return fib($n - 1) +
           fib($n - 2);
}

// Driver Code
$n = 9;
echo fib($n);

// This code is contributed
// by Akanksha Rai
?>

Javascript

<script>
    // Javascript code for above the approach.

    function fib(n)
    {
        if (n <= 1)
            return n;
        return fib(n - 1) + fib(n - 2);
    }

    let n = 9;
      document.write(fib(n));

</script>

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(n⁰2^n/1) 
  = O(2ⁿ) 
  
• 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(n⁰2^n/2) 
  = O(2^n/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(n^ka^n/b) 
  T(n)= O(n⁰3^n/1) 
  T(n)= 3ⁿ
  
• 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(n^k+1) 
  T(n)= O(n²⁺¹) 
  T(n)= O(n³) 
  
• 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)