Algorithms

Published By:

Physics Wallah

ISBN: 978-93-94342-39-2

Mobile App: Physics Wallah (Available on Play Store)

Website: www.pw.live
Email: support@pw.live

Rights
All rights will be reserved by Publisher. No part of this book may be used or reproduced in any manner
whatsoever without the written permission from author or publisher.
In the interest of student's community:
Circulation of soft copy of Book(s) in PDF or other equivalent format(s) through any social media channels,
emails, etc. or any other channels through mobiles, laptops or desktop is a criminal offence. Anybody
circulating, downloading, storing, soft copy of the book on his device(s) is in breach of Copyright Act. Further
Photocopying of this book or any of its material is also illegal. Do not download or forward in case you come
across any such soft copy material.

Disclaimer
A team of PW experts and faculties with an understanding of the subject has worked hard for the books.
While the author and publisher have used their best efforts in preparing these books. The content has been
checked for accuracy. As the book is intended for educational purposes, the author shall not be responsible for
any errors contained in the book.
The publication is designed to provide accurate and authoritative information with regard to the subject matter
covered.
This book and the individual contribution contained in it are protected under copyright by the publisher.
(This Module shall only be Used for Educational Purpose.)
 Design Against Static Load

INDEX
1. Asymptotic Notation ........................................................................................................... 6.1 – 6.18

2. Divide and Conquer .............................................................................................................. 6.19 – 6.25

3. Greedy Technique ............................................................................................................... 6.26 – 6.29

4. Dynamic Programming ......................................................................................................... 6.30 – 6.34

GATE-O-PEDIA COMPUTER SCIENCE & INFORMATION TECHNOLOGY

 Algorithm

1 ASYMPTOTIC
NOTATION

1.1 Introduction of Course

1.2 Algorithm Concept and Life Cycle Steps

1.2.1 Algorithm
• An Algorithm consists finite number of steps to solve any problem.
• Every step involves some operations and each operation must be definite and effective.

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK

6.1
 Algorithm

1.2.2 Life Cycle Steps

1.3 Needs of Analysis

In performance comparison comparing different algorithms for optimal solution.

1.3.1 Time Complexity
Time complexity of an algorithm quantifies the amount of time taken by an algorithm to run as a function of the input size.

1.3.2 Space Complexity

Space complexity of an algorithm quantifies the amount of space or memory taken by an algorithm to run as a function of input
size.

Note:
To find the time complexity of an algorithm, find the loops and also consider larger loops.
Space complexity is dependent on two things input size and some extra space (stack space link, space list etc).

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK

6.2
 Algorithm

1.4 Methodology of Analysis

1.5 Types of Analysis

Worst Case
The input class for which the algorithm does maximum work and hence, take maximum time.

Best Case
The input class for which the algorithm does minimum work hence, take minimum time.

Average Case
Average case can be calculated form best case to worst case.

1.6 Asymptotic Notations

Suppose, T(n) be a function of time for any algorithm.

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK

6.3
 Algorithm

1.7 Types of Asymptotic Notations

1.7.1 Big O – Notation

Two Functions f (n), g (n)
f (n) = O ( g (n))
When the growth of g (n) is same or higher than f (n) like a  b
Example:
f (n) = 3n + 10, g (n) = n2 + 2n + 5
f (n) = O( g (n))

1.7.2 Ω - Notation
f (n) = ( g (n))
 f (n)  C  g (n) (a  b)
Example: 3n = (2n )

1.7.3  - Notation
If f(n) ≤ g(n)
And
f(n) ≥ g(n)

f(n) = g(n)
∴ f(n) = (g(n))

Example:
f(n) = 2n2, g(n) = n+10
f(n) > g(n) here
so, f(n) = Ω(g(n)) or g(n)=O(f(n))

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK

6.4
 Algorithm

1.7.4. Properties with respect to asymptotic notations

Reflexive Symmetric Transitive Transpose symmetric

Big oh (O)  ×  
Big omega ()  ×  
Theta ()    ×
Small oh (o) × ×  
Small omega () × ×  

Example 1. Consider the following function

n
f (n) =  p = q
p =1
Which of the following is/are true for ‘q’
(a) (n4) (b) (n5) (c) O(n5) (d) (n3)
Solution: (a, c, d)
n
f (n) =  P3
P =1
= 13 + 23 + 33 + 43 ................. + n3
2
  n +1
=  n 
  2 
= O(n4) or  (n4)
=  (n4)
Example 2. Consider the following functions:
n
f (n) =  P½ = q
P =1
Find the value of q in terms of asymptotic notation.
n
Solution: f (n) =  P½
P =1

= 1 + ( 2) + ( 3) + .......
½ ½

2  32 
= n −1
3  
2 32 2
= n −
3 3
1.5
= O(n )
= O(n n )
Example 3. Arrange the following functions in increasing order.
f1 = n log n, f2 = n , f3 = 2n , f4 = 3n , f5 = n!, f6 = nn , f7 = log n , f8 = 100n log n
→ f7  f 2  fl = f8  f3  f 4  f5  f6

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK

6.5
 Algorithm

Example 4. Arrange the following functions in increasing order.

f1 = 10, f2 = n , f3 = log log n, f4 = (log n)2 , f5 = n2
f6 = n log n, f7 = n!, f8 = 2n , f9 = nn , f10 = n2 log n
→ f1  f3  f 4  f 2  f6  f5  f10  f8  f7  f9

Example 5. Arrange the following functions in increasing order.

f1 = log log n f9 = n log log n
f2 = log n f10 = n2 log n
f3 = (log n)2 f11 = n3
f4 = log n f12 = 2n
f5 = n1/10 f13 = en
f6 = n f14 = n !
f7 = n2 f15 = nn
f8 = n log n f16 = n3/2
f1 < f4 < f2 < f3 < f5 < f6 < f9 < f8 < f16 < f7 < f10 < f11 < f12 < f13 < f14 < f15
alogb c  clogb a
 2log2 n  nlog2 2 = n

Example 6. Arrange the following functions in increasing order.

f1 = n! , f2 = nn
f1 = n  (n − 1)(n − 2)  ...  3  2  1
f 2 = n  n  n  n  ...  n  n  n
f 2  f1
 f1 = O( f 2 )

2n  3n  4n  n!  nn

Question.
Which of following is TRUE?
(1) 2log2 n = O(n 2 ) TRUE
(2) n2  23log2 n = O(n5 ) TRUE
(3) 2n = O(22n ) TRUE
(4) log n = O(log log n) FALSE
(5) log log n = O(n log n) TRUE
Solution:
(1) 2log2 n = O(n 2 )
= nlog2 2
=n
GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK
6.6
 Algorithm

= n = O(n2 )
(2) n2  23log2 n = O(n5 )
= n 2  n3log 2 2
= n 2  n3
= n5
= n5 = O(n5 )
(3) 2n = 22 n
2n = 2n.2n
2 n  22 n
2n = O(22n ) True

(4) log n  loglog n

log n  O(log n)
False
(5) log log n  n log n
loglog n = O(n log n)
True

1.8. Analysis of an Algorithm

Algorithms

Without Loop Interactive Algorithm Recursive Algorithm

1.8.1 Without loop

Example: int fun (in + n)

{
return n*(n+1)/2;
}

Solution.
Here 1 multiply, 1 division, 1 addition
⸫ O (1) [no loops, no recursion]
1.8.2. Iterative Algorithm Analysis
Example 1:
for (i =1; i ≤ n; i=i*2)
printf(“Sushil”)

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK

6.7
 Algorithm

Solution.
i=1, 2, 22, 23 ..., 2k
→
2k ≤ n
k log 2 ≤ log n
log n
k≤
log 2
⸫ k ≤ log 2 n
k = log2 n
So, this will execute log2 n +1 time and Complexity O ( log 2 n )

Example 2:
For (i=1; i ≤ n; i=i*3)
printf(“Aaveg”);

Solution.
So, this will execute log3 n + 1 time and complexity O ( log3 n )
➢ i = 1→2→4→8→16→...→n
i = n→n/2→n/4→n/8→...1

Example 3:
for (i = 1; i ≤ n; i++)
{
for (j=1; j ≤ 10; j++)
{
printf(“Dhananjay”);
}
}

Solution.
This will execute 10⸳n times and complexity O(n)

Example 4:
for (i = 1; i <= n; i = i*3)
for (j = 1; j ≤ n; j++)
printf(“Prapti”);
Solution.
( )
Total n log3 n + 1 time execute and Complexity = O ( n log3 n )

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK

6.8
 Algorithm

1.8.3. Recursive Algorithm Analysis

Example 1:
void fun (in + n) T(n)
{
if (n > 0) 1 compare; C1 time
{
if (“% d”, n); C2 time
fun (n - 1); T(n-1)
}
}
Let T(n) be the Complexity time taken by algo for n size i/p
Solution.
T(n) = C1+C2+T(n-1)
T(n) =T(n-1) + C n>0

T (0) = C Constant

T(n) = C; n=0
T(n) = T (n - 1) + C; n > 0

Example 2:
void fun (in + n) T (n)
{
if (n > 0) C1 time
{
for (i = 1; i <= n; i + 1) n time
printf(“Hello”);
fun (n - 1); T (n - 1)
}
}
Solution.
T(n) = C1 + n - 1 + T (n - 1)
= T (n - 1) + n n>0
T (0) = C n=0

Example 3:
void fun (in + n) T(n)
{
if (n > 0) C1
{
for (i = 1; i < = n; i = i*2) log2 n

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK

6.9
 Algorithm

printf(“Divyajyoti”);
fun (n - 1); T (n - 1)
}
}

Solution. T (n) = T (n - 1) + O ( log 2 n ); n > 0

or
T (n) = T (n - 1) + log 2 n
T (0) = C or n = 0
T (0) = O (1)

1.9 Solving Recurrence Relation

1.9.1 Substitution Method
Example: (1)
T (n) = T (n - 1) + C
T (1) = C

n size on problem n – 1 size x1 convert them

T (n) = T (n -1) + C

[ T (n - 2) + C] + C
T (n) = T (n - 2) + 2C

= T (n - 3) +3C
T (n) = T (n - k) + kC
⸫n–k=1
T (n) = T (1) + (n - 1) C
= C + (n - 1) C
T (n) = O (n)

Example (2)

T (n) = T (n - 1) + C⸳n
T (1) = C
Solution.
⸫ T (n) = T (n - 1) + C⸳n
= [T (n - 2) + C⸳(n – 1)] + C⸳n
= [T (n - 3) + C⸳(n – 2)] + C (n - 1) + C⸳n
= T (n - 3) + (n - 2)⸳C + (n - 1)⸳C + n⸳C
= T (n - k) + C (n – k +1) + C (n – k + 2) + ... + C (n – k + k)
⸫ n – k =1
T (n) = T (1) + T (2) + C (3) + C (4) + ... + C (n - 1) + C (n)
= C + C (2) + (3) C + 4 (C) + ... + (n - 1) C + (n)⸳C
= C [1 + 2 + 3 + ... + n]

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK

6.10
 Algorithm

(n + 1)
= C⸳n
2
2
= O (n )

Example (3)

T (n) = T (n/2) + C
T (1) = 1

Solution.

T (n) = T (n/2) + C

= [T (n/22) + C] + C
= T (n/4) + 2C

= T (n/23) + 3C
T (n) = T (n/2k) + kC
= (n/2k) = 2
T (n) = T (2) + ( log 2 n - 1) C
= 1 + ( log 2 n - 1) C
= O (log n)

Example (4)

T (1) = 1

T (n)= 2T (n/2) + C

  n  
Solution. T(n) = 2 2T  2  + C + C
 2  

 n  2
= 22 T  +2 C + C
 22 
  n 
= 22  2T  3  + C + 2C + C
 2  

 n 2
= 23 T   + 2 C + 2C + C
 23 
 n  k −1
= 2k T  +2 C + 2k − 2 C + ... + 21  C + C
 2k 

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK

6.11
 Algorithm

n
k
= 1  n = 2k
2
→ T (n) = nT (1) + 2k - 1⸳ C + 2k - 2⸳ C + ... + 2C + C
= 2k + 2k - 1⸳ C + 2k – 2 + ... + 2C + C
= 2k + C (2k-1 + 2k-2 + ... + 21 + 20)

(2k − 1)
= 2k + C
2 −1
= 2k + C (2k - 1)
= 2k + 2k⸳ C – C
= n⸳C
= O (n)

1.9.2 Master’s Method

n
T (n) = aT   + Θ (nk (log n) p)
b
a ≥ 1, b > 1, k ≥ 0, p = real number

If a > bk or logb a  k

(
T (n) = Θ nlogb a )
n
Question 1. T (n) = 2T   + (n)0log n
 2
Solution. a = 2, b = 2, k = 0
a > bk; 2 > 20; 2 > 1
T (n) = Θ (n)
n
Question 2. T (n) = 2T   + n
 2
Solution. a = 2, b = 2, k = 1, p = 0
T(n) = Θ (n ⸳log n)

 n
Question 3. T(n)=2 T   + n log n
 2

Solution. a = 2, b = 2, k = 1, p = 1

⸫ T (n) = Θ( n (log n)2)

(b) If p < 0 then T (n)

T (n) = O (nk)
GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK
6.12
 Algorithm

 n
Question 4. T(n) = T   + C
2
Solution.
T(n) = Θ (n2log n)

1.9.3. Recursive Tree

n
(1) T(n) = 2T   + C
 2
T (1) = C

n
k
= 1 → n = 2k → k = log 2 n
2
Total Work done = C + 2C + 22C + 23C + ... + 2kC
= C (1 + 2 + 22 + ... + 2k)
 2k +1 − 1 
= c
 2 − 1 
 

= C (2k+1 - 1
= C (2⸳2k - 1)
= C (2n - 1)
= O (n)

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK

6.13
 Algorithm

n
(2) T (n) = 2T   + n
 2

n
k
− 1; n − 2k ; k − log 2 n
2
⸫ n + n + n + ... + n

=kn
= n nlog 2 n

= O(nlog 2 n)

n
(3) T (n) = 4T   + n
 2

n = 2k, k = log2 n

n 2n k n

= n + 4   + 4   + ... + 4  
 2  2  2

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK

6.14
 Algorithm

= n 1 + 2 + 22 + 23 + ... + 2k 
 

 2k +1 − 1 
= n
 2 − 1 
 

(
= n 2  2k−1 )
= n ( 2n ) − 1

( )
= O n2

n  2n 
(4) T (n) = T   + T   + n T(1) = 1
 3  3

n
− 1; n − 3i; i − log3 n 3
3i
= n + n +...+ log3 n T (n)
= (n + n + n +...+ log3 n) ≥ n + ... + log3 n
Ω(n⸳ log 3/ 2 n )

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.15

 Algorithm

1.10 Recurrence Relations and their Time Complexity

T (n) = C; n = 2
O (logn)
T(n) = 2 T(√𝑛) + C; n > 2
T (n) = C; n = 2
O(n)
T(n) = T(n – 1) + C ; n > 2
T (n) = C; n = 1
O(n2)
T(n) = T(n – 1) + n + C ; n > 2
T (n) = C; n = 1
O(2n)
T(n) = 2T(n – 1) + C ; n > 1
T (n) = C; n = 1
n (n)
T(n) = 2T   + C ; n > 1
 2
T (n) = C; n = 1
n (nlogn)
T(n) = 2T   + n ; n > 1
 2
T (n) = C; n = 1
n (logn)
T(n) = T   + C; n > 1
 2
T (n) = 1; n = 2
T(n) = T ( n ) + C; n > 2 (loglogn)

1.11 Space Complexities

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.16

 Algorithm

Int n, A[n];
Algorithm Rsum(A, n)
{
if (n = 1) return (A(1));
else;
return (A[n] + RSum(A, (n–1));
}

• Time Complexity = O(n)

• Space Complexity
• We need stack space
• Stack is used to store activation records of function calls
• Size of activation records is trivial
• Stack size that we need = O(n)
• Space complexity = O(n)

Algorithm A(n)
{
if (n = 1) return;
else;
{
n
A ;
 2
}
}

Recurrence relation
T(n) = C; n = 1
n
T(n) = T   + C; n > 1
 2
Time Complexity = O(log n)

Space Complexity
• Space complexity will depend on number of activation record pushed into the stack
Suppose, n = 16
A (1)
A (2)
For n = 2K we are pushing
A (4)
the ‘K’ activation record
A (8)
A (16)

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.17

 Algorithm

 Space Complexity

n = 2K
log n = Klog2 2
K = log 2 n
Space Complexity = O(log n)

Example 3
Algorithm A(n)
{
if (n = 2) return;
else;
return (A n );
}

Solution:
T (n) = 1; n =2
T (n) = T ( n ) +C; n > 2
Time Complexity = O (loglogn)

Space Complexity
Suppose n = 16

A(1)
A(2)
A(4)
A(16)
n
 For 2 2k manner we are pushing in stack
n
2 2 2
k

n
log 2 2  log 2 2
2k
n  2K
K  log 2 n

Space complexity = O log 2 n ( )

❑❑❑

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.18

 Algorithm

2 DIVIDE AND CONQUER

2.1 DAC Application

2.2 Finding Maximum Minimum element

Recurrence Relation:
 1 if n = 1 or n = 2
 
T (n) =   n  
  2
2 T + 1; n  2 
   

Time Complexity:
T (n) = O(n)

• Time complexity is same for every case (Best case/Worst case).

Space Complexity:

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.19

 Algorithm

Space Complexity = O(n) + O(log n)

= O(n)

Number of comparisons to find maximum / minimum element on an given array of n elements:

3n
Comparison = −2
2

2.3 Power of an Element

Recurrence relation:
1 if n = 1 
 
T (n) =   n  
T  2  + 1; n  1
   

Time Complexity:
n
T ( n) = T   + C
2
T (n) = O(log n)

Space Complexity:

Space Complexity = 4B + O(logn)

= O(logn)
Number of multiplications to find an
Multiplication = O(logn)

2.4 Binary Search

Given a sorted array and an element x, need to return the index of element x if it is present then 1, otherwise – 1.
Recurrence relation:
1 ; n =1 
 
T (n) =   n  
T  2  + C; n  1
   

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.20

 Algorithm

Time Complexity:

Space Complexity:

Space complexity = O(n) + O(1)

= O (n)

2.5 Merge Algorithm

• Merging two sorted sub arrays of input size m,n.

• Number of comparisons to merge two sorted sub arrays of size m,n.

Comparisons = m + n – 1 (worst case)

Number of moves =m + n (Outplace Algorithm)

Number of comparisons in best case of merging two sorted subarrays of size m, n.

comparisons = min (m, n)

Moves = m + n (Always)

Note:
Best Case comes in comparisons no effect on moves.

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.21

 Algorithm

2.5.1 Merge Sort Algorithm:

Note:
• In GATE exam if merge sort given then always consider outplace.
• If array size very large, merge sort preferable.
• If array size very small, then prefer insertion sort.
• Merge sort is stable sorting technique.

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.22

 Algorithm

2.6 Quick Sort Algorithm

th
n
Example 1: In Quick for sorting n elements, the   smallest element is selected as pivot. what is the worst-case time
 16 
Complexity?

Solution.
n  15n 
T (n) = T   +T   +O (n)
 16   16 
= (solve by recursive tree method)

Example 2: The median of n elements can be found in O (n) time then, what is the time complexity of quick sort algo in
which median selected as pivot?

Solution.
T (n) = O (n) + C + O (n) + T (n/2) + T (n/2)

Find median swap median Partition algo

with last
= 2T (n/2) + C ∙ n
= O(n log n)

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.23

 Algorithm

2.6.1 Randomized Quick Sort

• In Randomized quick short algorithm selection of pivot element can be taken randomly.

2.7 Counting Number of Inversion

• Counting number of inversion on given an array of an element.
Time complexity T(n) = O(nlogn)

2.8 Selection Procedure

Find Kth smallest on given an array of an element and integer K.

Time Complexity:
T(n) = O(n2)

Space complexity:
Space Complexity = O(n)

2.9 Strassen’s matrix Multiplication

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.24

 Algorithm

2.10 Comparison Based Sorting Algorithms

Sorting Basic logic of sorting Algo BC AC WC Stable Inplace

Algorithm sorting sorting

Quick sort Choose pivot element place in (nlogn) (nlogn) (n2) No Yes
correct position

Merge sort Divide to equal parts recursively sort (nlogn) (nlogn) = (nlogn) = n Yes No
each sub part & marge them n logn log n

Heap sort Build heap(max) delete max place (nlogn) (nlogn) (nlogn) No Yes

Bubble sort Compare exchange (n) (n2) (n2) Yes Yes

Selection sort Find position of min element (n2) (n2) (n2) No Yes
from [1 to n]

Insertion sort Insert a [i + 1] into correct position (n) (n2) (n2) Yes Yes

❑❑❑

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.25

 Algorithm

3 GREEDY
TECHNIQUE
3.1 Greedy Technique
• Greedy method is an algorithm design strategy used for solving problems where solution are seen as result of making
a sequence of decisions.
• A problem may contain more than one solution.

3.2 Terminology

3.3 Applications of greedy

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.26

 Algorithm

3.4 Knapsack Problem

Time complexity T(n) = O(nlogn)

3.5 Job Sequence with Deadline

• Single CPU only.
• Arrival time of each job is same.
• No pre-emption.

3.6 Optimal Merge Pattern

• This is a problem related to merging of files. Given a set of n-files in sorted order. It is required to merge
them into a single sorted file with 2-way merging.
• This problem is like merging process in merge sort. In merge sort we were interested in number of
comparisons but in optimal merge pattern we are interested in record movement (i.e moving a record from
one file to another file).
o If file F1 has 'n' records and file 'F2 ' has 'm' records then number of record movement will be 'm+n'. 1 2
The problem of optimal merge pattern involves merging of n-files (n≥2).
• At any point choose two records with least weight merge them and put them in list and continue it until all records are
merged.
• Time complexity T(n) = O(nlogn)
• Space complexity = O(n)

3.7 Huffman Coding

• Huffman coding is essentially a non-uniform encoding with convention that the character with higher
frequency (probability) of occurrence will be enclosed with less number of bits.
• It comes under data compression technique.
• Time complexity T(n) = O(nlogn)

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.27

 Algorithm

3.8 Minimum Cost Spanning Tree

3.8.1 Graph
Graph (V., E)

Set of vertices set of edges

• Let G(V, E) be a simple graph then

V(V-1)
Maximum edges =
2
V(V-1)
E
2
E  C.V2 C is constant

Note:
E = O(V2)
Log E = O(logV)
3.8.2 Graph Representation
Graph Representation

Adjacency matrix Adjacency list

• For more edges (Dense Graph) Adj. matrix is better (density more).
• For less edge (sparse graph) Adj list is better.

Matrix List
(1) Finding degree of vertex Time Complexity O(V) Every Case O(1) Best Case
O(V1) Worst Case
O(V2) Every Case O(V+2E) Worst Case
(2)Finding total edges  Time Complexity O(V) Best Case
O(1) O(V-1) Worst Case
(3) Finding 2-vertices adjacent (or)not  Time Complexity O(1) Best Case

O(V2) Every Case O(V+E) Every Case

(4) G(V,E)  space

3.8.3 What is Spanning Tree

A subgraph T(V, E’) of G(V, E) where E’ is the subset of (Eʹ E) is a spanning tree iff ‘T’ is a tree.
A sub graph G(‘V, E’) of G(V, E) is said to be spanning tree.
(1) T’ should contain all vertices of G
(2) T’ should contain (V-1) edged where V is number of vertices without cycle.

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.28

 Algorithm

(3) T’ should connected.

3.8.4 Minimum Cost Spanning Tree
Minimum cost spanning tree is the one in which cost of the spanning tree formed should be minimum.
3.8.5 Prims Algorithm
• Select Any vertex
Time complexity = V + VlogV + 2E + ElogV
= O(E + V)logV

Using Sorted Array & Adjacency List

V + 2E + E × V = O(EV)

Using Sorted Array & Adjacency List

V × O(1) + V2 + E × V= O(EV)

3.8.6 Kruskal algorithm

• Take first minimum edge
Time complexity = E log E + (V + E)
= O(E log E) = O(ElogV)
If edges are already sorted
TC = O(E + V)

3.9 Single Source Shortest Path

3.9.1 Dijkstra Algorithm
• Using min heap & adjacency list = O(E + V)logV
2
• Using adjacency Matrix & Min heap = O(V ElogV)

2
• Using adjacency list & Unsorted Array = O(V )

• Using adjacency list & Sorted Doubly Linked List = O(EV)

3.9.2 Bellman-Ford
• Time Complexity = O(EV)
• If negative edge weight cycle then for some vertices Incorrect answer.
❑❑❑

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.29

 Algorithm

4 DYNAMIC
PROGRAMMING
4.1 Dynamic Programming
In dynamic programming for optimal solution always computes distinct function calls.

4.2 Terminology

4.3 Application of Dynamic Programming

4.4 Fibonacci Series

• Time complexity T(n) = O(nlogn)
• Computes distinct function calls.

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.30

 Algorithm

4.5 Job Sequence with Deadline

• Single CPU only
• Arrival time of each job is same
• No pre-emption

4.6 Longest Common Sub sequence (LCS)

• For common subsequence always consider two strings:
• P = <ABCDB> – Q = <BDCABA>
• Common subsequences for both ‘p’ are
• S = <A>
• S = <AB>
• S = <CAB>
• S = <BDAB>
• A common subsequence of longest length is known as longest common subsequence.
• For above problem longest common subsequence will be of length u.
4.6.1 Applications of LCS
1. Genomics
2. Software engineering applications
3. Plagiarism
4. Data gathering system of search engines

4.6.2 Algorithm for LCS

LCS (p,q)
{
1. For i 0 to n − 1
L[i − 1] = 0
2. For j 0 to m − 1
L[−1, j ] = 0

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.31

 Algorithm

3. For i 0 to n − 1
For j 0 to m − 1
If ( p[i] = q[ j ]) then
L[i, j ] =1 + L (i − 1, j − 1];
else
L[i, j ] = max{L i , j − 1, L[i − 1, j ]}

}
• Time complexity of step 1 = O(n)
• Time complexity of step 2 = O(m)
• Time complexity of step 3 = O(mn)
• Total Time complexity = O(n) + O(m) + O(mn)
= O(mn)
• Space complexity = O[(M+1).(n+1)]
= O(mn)

4.7 Matrix Chain Multiplications

Two matrices ‘A’ and ‘B’ are compatible if and only number of column of first matrix must be equal to number of rows of
second matrix.

4.7.1 Brute force method

 1 2n 
Number of parenthesizing for a given chain is given by Catalan number:  Cn 
 n + 1 

Time complexity = O(nn)

Space complexity = O(n)

4.7.2 Algorithm For Matrix Chain Multiplication

The time complexity of multiply the given chain of n matrices <A1, A2 A3…. An> using dynamic programming (district
function call) is O(n3)
Space complexity = O(n2)

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.32

 Algorithm

4.8 O/1 Knapsack Problem

The maximum profit can be achieved by O/1 knapsack problem where capacity of problem is ‘p’ and number of objects are
‘q’.

4.9 Sum of Subset Problem

• Given n-elements and an integer 'm', it is required to determine whether there exists a subset of given n elements, whose
sum equal M.
• This is a decision problem (True/False).

4.9.1 Algorithm for Sum of Subset Problem

SoS(n, M, A)
// A [1 . . . n] is an array of elements
{
1. for i = 0 to n
for j = 0 to M
if (i > =0 and j = 0)
SoS [i, j] = T
else
if (i = 0 and j > 0)
SoS [i, j] = F;
else
if (A[i] > j)
SoS [i, j] = SoS [i – 1, j]
else
SoS [i, j] = SoS [i – 1, j] or
SoS [i – 1, j – A[i]]
}

GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.33

 Algorithm

4.9.2 Time Complexity of SoS

Two for loops are there thus repeating for (n * m) times. Thus, time complexity = O(n * m)
Time complexity of SoS becomes exponential if M = 2n
T.C = O(n × 2n)



GATE WALLAH COMPUTER SCIENCE & INFORMATION TECHNOLOGY HANDBOOK 6.34