C analysis of s trassens algorit hm 4 marks tn 7 tn2

c. Analysis of S trassen’s Algorit hm 4 marks
T(n) =7 * T(n/2) + Θ (n 2 )
a=7,b=2
=n lg7

37
case 1 of Master theorem
T(n) = Θ( n
lg7
) =O(n
2.81
)
d. 6 marks
The recursive relation is
T ( n ) = 2 T ( n /2) + M ( n ), where M ( n ) is linear in n .
Using Master's Theorem
Solution: a = 2, b = 2, c = 1  a = b c  Case 2
Hence T(n) ε O(n log n)
3 a. Recursion is the process of defining a problem (or the solution to a problem) in terms of (a
simpler version of) itself. An algorithm is said to be recursive if the same algorithm is invoked in
the body.
Recursion occurs where the definition of an entity refers to the entity itself. Recursion can be direct
when an entity refers to itself directly or indirect when it refers to other entities which refers to it.
A (Directly) recursive routine calls itself. Mutually recursive routines are an example of indirect
recursion. A (Directly) recursive data type contains pointers to instances of the data type. (3
marks)
b. T he Fibonacci algorithm is given below; (2
1
/
2
marks)
long fibonacci (int n) {
if( n == 1 || n == 2)
return 1;
else
return fibonacci(n – 1) + fibonacci(n – 2);
}
c. (6 marks)
Tower of Hanoi is a puzzle that consists of three pegs and five disks. Figure 1 shows the starting
position of the puzzle. The goal is to reposition the stack of disks from peg A to peg C by
moving one disk at a time, and, never placing a larger disk on top of a smaller disk.
Figure 1

38
The algorithm for solving the puzzle is given by:
Tower_Of_Hanoi(N, source, destination, helper):
If N==1:
Move disk from source to destination
Else:
Tower_Of_Hanoi (N-1, source, destination, helper)
Move disk from source to destination
Tower_Of_Hanoi (N-1, helper, destination, source)
The recurrence relation is
T(n) = a if n = 1
T(n) = 2T(n - 1) + b if n > 1
T(n) ε O(2 n )
d. (6 marks)
The time complexity of the Parallel-Product algorithm can be expressed as
T(n) = T(n/2) + O(n/2)
T(1) = 1
We can solve it as:
T(n) = T(n/2) + O(n/2)
= (T(n/2^2) + O(n/2^2)) + O(n/2)
= T(n/2^2) + O(n/2^2) + O(n/2)
= T(n/2^3) + O(n/2^3) + O(n/2^2) + O(n/2)
...
= T(n/2^i) + O(n/2^i) +...+ O(n/2^2) + O(n/2)
= T(n/2^log n) + O(n/2^log n) +...+ O(n/2^2) + O(n/2)
// We stop the expansion at i = log n because
2^log n = n //
= T(1) + O(n/2^log n) +...+ O(n/2^2) + O(n/2)
= 1 + O(n/2^log n +...+ n/2^2 + n/2)
= 1 + O(n*(1/2^log n +...+ 1/2^2 + 1/2)
= O(n)
4a. Analysis of the linear search algorithm
This is O(n) in the worst case and Ω (1) in the best case.
If the elements of an array A are distinct and query point q is indeed in the array then loop
executed (n + 1) / 2 average number of times. On average (as well as the worst case), sequential
search takes θ(n) time.
b.
i. Yes, the binary search algorithm is an improvement over the sequential search algorithm. This
is because it employs the Divide and Conquer approach which explains why it has increased
efficiency.
ii. Condition for best case – the element is the first element in the array

39
average case – the element is the middle element in the array
worst case – the element is the last element in the array
c.