L. D.

College of Engineering,
Ahmedabad

A Laboratory Manual for

Analysis and Design of Algorithms

(3150703)

B.E. Semester 5
(Computer Engineering)

Faculty Details:
1) Prof. H. K. GEVARIYA
2) Prof. S. A. PATEL
 3) Prof. S. R. MODI

L. D. College of Engineering, Ahmedabad

Certificate

This is to certify that Mr./Ms. ___________________________________

________ Enrollment No. _______________ of B.E. Semester _____
Computer Engineering of this Institute (GTU Code: _____) has satisfactorily
completed the Practical / Tutorial work for the subject Analysis and Design
of Algorithms (3150703) for the academic year 2023-2024.

Place: __________
Date: __________

Name and Sign of Faculty member

Head of the Department

Institute’s Vision
To contribute for sustainable development of nation through achieving excellence in
technical education and research while facilitating transformation of students into responsible
citizens and competent professionals.

Institute’s Mission
 To impart affordable and quality education in order to meet the needs of industries and
achieve excellence in teaching-learning process.

 To create a conducive research ambience that drives innovation and nurtures research-
oriented scholars and outstanding professionals.

 To collaborate with other academic & research institutes as well as industries in order to
strengthen education and multidisciplinary research.

 To promote equitable and harmonious growth of students, academicians, staff, society and
industries, thereby becoming a center of excellence in technical education.

 To practice and encourage high standards of professional ethics, transparency and

accountability.

Department’s Vision
 To Achieve Academic Excellence in Computer Engineering by Providing Value Based
Education.

Department’s Mission
 To produce graduates according to the needs of industry, government, society and
scientific community.

 To develop partnership with industries, research and development organizations and

government sectors for continuous improvement of faculties and students.

 To motivate students for participating in reputed conferences, workshops, seminars and

technical events to make them technocrats and entrepreneurs.

 To enhance the ability of students to address the real life issues by applying technical
expertise, human values and professional ethics.

 To inculcate habit of using free and open source software, latest technology and soft skills
so that they become competent professionals.

 To encourage faculty members to upgrade their skills and qualification through training
and higher studies at reputed universities.
Program Educational Objectives (PEOs)

 Provide computing solutions of complex problems as per business and societal needs.
 Procure requisite skills to pursue entrepreneurship, research and development, and
imbibe high degree of professionalism in the fields of computing.
 Embrace life-long learning and remain continuously employable.
 Work and excel in a highly competence supportive, multicultural and professional
environment which abiding to the legal and ethical responsibilities.
.

Program Specific Outcomes (PSOs)

 Graduates will be able to explore and propose effective solutions to the problems in the
area of Computer Engineering as per the needs of society and industry.
 Graduates will be able to apply standard practice and strategies to develop quality software
products using modern techniques, programming skills, tools & an open ended
programming environment and work in a team.
 Graduates will manifest the skills of continuous learning in the fast changing field of
Computer Engineering.
 Programme Outcomes (POs)

1. Engineering knowledge: Apply the knowledge of mathematics, science, engineering

fundamentals, and an engineering specialization to the solution of complex engineering
problems.
2. Problem analysis: Identify, formulate, review research literature, and analyze complex
engineering problems reaching substantiated conclusions using first principles of
mathematics, natural sciences, and engineering sciences.
3. Design/development of solutions: Design solutions for complex engineering problems and
design system components or processes that meet the specified needs with appropriate
consideration for the public health and safety, and the cultural, societal, and environmental
considerations.
4. Conduct investigations of complex problems: Use research-based knowledge and research
methods including design of experiments, analysis and interpretation of data, and synthesis
of the information to provide valid conclusions.
5. Modern tool usage: Create, select, and apply appropriate techniques, resources, and modern
engineering and IT tools including prediction and modeling to complex engineering activities
with an understanding of the limitations.
6. The engineer and society: Apply reasoning informed by the contextual knowledge to assess
societal, health, safety, legal and cultural issues and the consequent responsibilities relevant
to the professional engineering practice.
7. Environment and sustainability: Understand the impact of the professional engineering
solutions in societal and environmental contexts, and demonstrate the knowledge of, and
need for sustainable development.
8. Ethics: Apply ethical principles and commit to professional ethics and responsibilities and
norms of the engineering practice.
9. Individual and team work: Function effectively as an individual, and as a member or leader
in diverse teams, and in multidisciplinary settings.
10. Communication: Communicate effectively on complex engineering activities with the
engineering community and with society at large, such as, being able to comprehend and
write effective reports and design documentation, make effective presentations, and give and
receive clear instructions.
11. Project management and finance: Demonstrate knowledge and understanding of the
engineering and management principles and apply these to one’s own work, as a member and
leader in a team, to manage projects and in multidisciplinary environments.
12. Life-long learning: Recognize the need for, and have the preparation and ability to engage in
independent and life-long learning in the broadest context of technological change.
Analysis and Design of Algorithms (3150703)

Practical – Course Outcome matrix

Course Outcomes (Cos):

1. Analyze the asymptotic performance of algorithms.

2. Derive and solve recurrences describing the performance of divide-and-conquer algorithms.
3. Find optimal solution by applying various methods.
4. Apply pattern matching algorithms to find particular pattern.
5. Differentiate polynomial and nonpolynomial problems.
6. Explain the major graph algorithms and their analyses. Employ graphs to model engineering
problems, when appropriate.
Sr. CO
Objective(s) of Experiment CO2 CO3 CO4 CO5 CO6
No. 1

Implement a function for each of following problems

and count the number of steps executed/time taken by
each function on various inputs and write time
complexity of each function. Also draw a comparative
1. chart of number of input versus steps executed/time
√
taken. In each of the following function N will be
passed by user.
1. To calculate sum of 1 to N numbers using loop.
2. To calculate sum of 1 to N numbers using equation.
3. To calculate sum of 1 to N numbers using recursion.
Write user defined functions for the following sorting
methods and compare their performance by steps
executed/time taken for execution on various inputs of
random nature, ascending order and descending order
sorted data. Also draw a comparative chart of number
of input versus steps executed/time taken for each cases
2. √ √
(random, ascending, and descending).
1. Selection Sort
2. Bubble Sort
3. Insertion Sort
4. Merge Sort
5. Quick Sort
Compare the performance of linear search and binary
3. search for Best case, Average case and Worst case √ √
inputs.
4. Implement functions to print nth Fibonacci number √ √
using iteration and recursive method. Compare the
performance of two methods by counting number of
steps executed on various inputs. Also, draw a
comparative chart. (Fibonacci series 1, 1, 2, 3, 5, 8….
Analysis and Design of Algorithms (3150703)

Here 8 is the 6th Fibonacci number).

Implement program to solve problem of making a
5. √
change using dynamic programming.
Implement program of chain matrix multiplication
6. √
using dynamic programming.
Implement program to solve LCS problem using
7. √
dynamic programing.
Implement program to solve Knapsack problem using
8. √
dynamic programming.
Implement program for solution of fractional Knapsack
9. √
problem using greedy design technique.
Implement program for solution of Making Change
10. √
problem using greedy design technique
Implement program for Kruskal's algorithm to find
11. √ √
minimum spanning tree.
Implement program for Prim's algorithm to find
12. √ √
minimum spanning tree.
Implement DFS and BFS graph traversal techniques and
13. √
write its time complexities.

14. Implement Rabin-Karp string matching algorithm. √

Analysis and Design of Algorithms (3150703)

Index
(Progressive Assessment Sheet)

Sr. No. Objective(s) of Experiment Page Date of Date of Assessmen Sign. of

No. perform submiss t Teacher
ance ion Marks with date

Implement a function for each of following

problems and count the number of steps
executed/time taken by each function on
various inputs and write time complexity of
each function. Also draw a comparative chart
of number of input versus steps executed/time
1. taken. In each of the following function N will
be passed by user.
1. To calculate sum of 1 to N numbers using
loop.
2. To calculate sum of 1 to N numbers using
equation.
3. To calculate sum of 1 to N numbers using
recursion.
Write user defined functions for the following
sorting methods and compare their
performance by steps executed/time taken for
execution on various inputs of random nature,
ascending order and descending order sorted
data. Also draw a comparative chart of number
of input versus steps executed/time taken for
2.
each cases (random, ascending, and
descending).
1. Selection Sort
2. Bubble Sort
3. Insertion Sort
4. Merge Sort
5. Quick Sort
Compare the performance of linear search and
3. binary search for Best case, Average case and
Worst case inputs.
4. Implement functions to print nth Fibonacci
number using iteration and recursive method.
Compare the performance of two methods by
counting number of steps executed on various
inputs. Also, draw a comparative chart.
(Fibonacci series 1, 1, 2, 3, 5, 8….. Here 8 is
Analysis and Design of Algorithms (3150703)

the 6th Fibonacci number).

Implement program to solve problem of
5.
making a change using dynamic programming.
Implement program of chain matrix
6.
multiplication using dynamic programming.
Implement program to solve LCS problem
7.
using dynamic programing.
Implement program to solve Knapsack
8.
problem using dynamic programming.
Implement program for solution of fractional
9. Knapsack problem using greedy design
technique.
Implement program for solution of Making
10.
Change problem using greedy design technique
Implement program for Kruskal's algorithm to
11.
find minimum spanning tree.
Implement program for Prim's algorithm to
12.
find minimum spanning tree.
Implement DFS and BFS graph traversal
13.
techniques and write its time complexities.
Implement Rabin-Karp string matching
14.
algorithm.
Total
 Experiment No: 1
Implement a function for each of following problems and count the number of steps executed/time
taken by each function on various inputs and write equation for the growth rate of each function.
Also draw a comparative chart of number of input versus steps executed/time taken. In each of the
following function N will be passed by user.
1. To calculate sum of 1 to N numbers using loop.
2. To calculate sum of 1 to N numbers using equation.
3. To calculate sum of 1 to N numbers using recursion.

Date:

Competency and Practical Skills: Algorithmic thinking, Programming Skills, Performance

analysis, and Mathematical skills

Relevant CO: CO1

Objectives: (a) Compare performance of various algorithms

(b) Judge best algorithm in terms of growth rate or steps executed

Equipment/Instruments: Computer System, Any C language editor

Theory:

1. Below are the steps to calculate sum of 1 to N numbers using loop

1. Take an input value for N.

2. Initialize a variable sum to zero.
3. Start a loop that iterates from i=1 to i=N.
4. In each iteration, add the value of i to the sum variable.
5. After the loop completes, output the value of sum.

2. Below are the steps to calculate sum of 1 to N numbers using equation

1. Take an input value for N.

2. Calculate sum as N*(N+1)/2.
3. Output the value of sum.

3. Below are the steps to calculate sum of 1 to N numbers using recursion

1. Take an input value for N.

2. Define a recursive function sum(n) that takes an integer argument n and returns the
sum of 1 to n.
3. In the sum(n) function, check if n equals 1. If it does, return 1 (the base case).
4. Otherwise, return the sum of n and the result of calling sum(n-1).
5. Output the result.
Implement three functions based on above steps and calculate the time taken by each
functions on various inputs ranging from 100 to 500.
Observations:
Write observation based on time taken executed by each algorithm.

Result: Complete the below table based on your implementation of functions and time taken by
each function.
Time taken
Inputs
Loop method Equations Recursion
100

200

300

400

500

Equation

Chart:
<Draw Comparative Chart of inputs versus time taken by each algorithm>

Conclusion: (Sufficient space to be provided)

Quiz:
1. What is the meaning of constant growth rate of an algorithm?
Answer:

2. If one algorithm has a growth rate of n2 and second algorithm has a growth rate of n then
which algorithm execute faster? Why?
Answer:

Suggested Reference:
1. "Introduction to Algorithms" by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest,
and Clifford Stein
2. “Fundamentals of Algorithms”by E. Horowitz et al.

References used by the students:

 Experiment No: 2
Write user defined functions for the following sorting methods and compare their performance by
steps executed/time taken for execution on various inputs of random nature, ascending order and
descending order sorted data. Also, draw a comparative chart of number of inputs versus steps
executed/time taken for each cases (random, ascending, and descending).
1. Selection Sort
2. Bubble Sort
3. Insertion Sort
4. Merge Sort
5. Quick Sort
Date:

Competency and Practical Skills: Algorithmic thinking, Programming Skills, Performance

analysis, and Mathematical skills

Relevant CO: CO1, CO2

Objectives: (a) Compare performance of various algorithms.

(b) Judge best sorting algorithm on sorted and random inputs in terms of growth
rate/time complexity.
(c) Derive time complexity from steps count on various inputs.

Equipment/Instruments: Computer System, Any C language editor

Theory:
Implement the program to use above sorting functions and calculate the time taken by each
functions on various inputs ranging from 1000 to 5000.

1. Selection Sort Program in C

#include <stdio.h>
#include <time.h>
int main()
{
int n,temp,i,a[10],j; time_t start,end; double tc;
printf("Enter total number:"); scanf("%d",&n); for(i=0;i<n;i++){
scanf("%d",&a[i]);
}
start=clock();
for(i=0;i<n;i++){ for(j=i+1;j<n;j++){ if(a[i]>a[j]){
temp=a[i]; a[i]=a[j]; a[j]=temp;
}
}

}
end=clock();
for(i=0;i<n;i++){ printf("%d ",a[i]);
}
tc=difftime(end, start)/CLOCKS_PER_SEC; printf("\nTime Taken: %lf ",tc);
return 0;
}
2. Bubble Sort Program in C

Bubble sort:

#include <stdio.h>
#include <time.h>
int main(){
int n,a[10],t,i,j; time_t start,end; double tc;
printf("Enter the total number:"); scanf("%d",&n); for(i=0;i<n;i++)
{
scanf("%d",&a[i]);
}
start=clock();
for(i=0;i<n-1;i++){
for(j=0;j<n-1;j++){
if(a[j]>a[j+1]){ t=a[j]; a[j]=a[j+1]; a[j+1]=t;
}
}
}
end=clock();
for(i=0;i<n;i++){ printf("%d ",a[i]);
}
tc=difftime(end, start)/CLOCKS_PER_SEC; printf("\nTime Taken: %lf ",tc);
return 0;
}
3. Insertion Sort Program in C

#include <stdio.h>
#include <time.h>
int main() {
int n,temp,i,a[10],j,k;
time_t start,end;
double tc;
printf("Enter total number:");
scanf("%d",&n);
start=clock();
for(i=0;i<n;i++)
{
scanf("%d",&a[i]);
for(k=0;k<i+1;k++)
{
for(j=k+1;j<i+1;j++)
{
if(a[k]>a[j])
{
temp=a[k];
a[k]=a[j];
a[j]=temp;
}
}
}
}
end=clock();
for(i=0;i<n;i++)
{
printf("%d ",a[i]);
}
tc=difftime(end, start)/CLOCKS_PER_SEC;
printf("\nTime Taken: %lf ",tc);
return 0;
}
4. Merge Sort Program in C

#include <stdio.h>
#include <time.h>
#define max 10

int a[7]={7,6,5,4,3,2,1};
int b[10];
time_t start,end;
double tc;

void merging(int l, int m, int h)

{
int l1,l2,i;
for(l1=l, l2=m+1, i=l; l1<=m && l2<=h; i++)
{
if(a[l1]<a[l2])
{
b[i]=a[l1++];
}
else
b[i]=a[l2++];
}
while(l1<=m) b[i++]=a[l1++];
while(l2<=h) b[i++]=a[l2++];
for(i=l;i<=h;i++)
{
a[i]=b[i];
}
}

void sort(int l, int h)

{
if(l<h)
{
int m; m=(l+h)/2;
sort(l,m);
sort(m+1,h);
merging(l,m,h);
}
}

int main()
{
printf("Hello");
int i;

start=clock();
sort(0,6);
end=clock();

for(i=0;i<7;i++)
{
printf("%d ",a[i]);
}
tc=difftime(end, start)/CLOCKS_PER_SEC;
printf(“\nTime Taken: %lf ",tc);
return 0;
}
5. Quick Sort Program in C

#include <stdio.h>
#include<time.h>

void quicksort(int number[25],int first,int last)

{
int i, j, pivot, temp;

if(first<last)
{
pivot=first; i=first; j=last;

while(i<j)
{
while(number[i]<=number[pivot]&&i<last)
i++;
while(number[j]>number[pivot]) j--;
if(i<j)
{
temp=number[i]; number[i]=number[j]; number[j]=temp;
}
}
temp=number[pivot]; number[pivot]=number[j]; number[j]=temp; quicksort(number,first,j-1);
quicksort(number,j+1,last);
}
}

int main()
{
int i, count, number[25];
time_t start,end;

printf("How many elements are u going to enter?: ");

scanf("%d",&count);

printf("Enter %d elements: ", count);

for(i=0;i<count;i++)
scanf("%d",&number[i]);

start=clock();
quicksort(number,0,count-1);
end=clock();

printf("Order of Sorted elements: "); for(i=0;i<count;i++)

printf(" %d",number[i]);

tc=difftime(end, start)/CLOCKS_PER_SEC; printf("\nTime Taken: %lf ",tc);

return 0;
}
Observations:
Write observation based on time taken by each algorithm.

Result: Complete the below table based on your implementation of functions and time taken by
each function. Also, prepare similar tables for ascending order sorted data and descending
order sorted data.

Time taken (Random Data)

Inputs
Selection Bubble Insertion Merge Quick
1000
2000
3000
4000
5000
Time
Complexity

Chart:
<Draw Comparative Charts of inputs versus time taken on various data (Random, ascending order sorted
and descending order sorted data) by each algorithm.>
Sample Chart is as below:

Sorting Functions Analysis on Random Data

300000

250000

200000

150000

100000

50000

0
100 200 300 400 500

Selection Insertion Bubble Quick Merge

Conclusion:
Quiz:
1. Which sorting function execute faster in case of ascending order sorted data?
Answer:

2. Which sorting function execute faster in case of descending order sorted data?
Answer:

3. Which sorting function execute faster in case of random data?

Answer:

4. On what kind of data, the best case of Bubble sort occurs?

Answer:

5. On what kind of data, the worst case of Bubble sort occurs?

Answer:

6. On what kind of data, the best case of Quick sort occurs?

Answer:

7. On what kind of data, the worst case of Quick sort occurs?

Answer:

8. Which sorting algorithms are in-place sorting algorithms?

Answer:

9. Which sorting algorithms are stable sorting algorithms?

Answer:

Suggested Reference:
1. "Introduction to Algorithms" by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest,
and Clifford Stein
2. “Fundamentals of Algorithms”by E. Horowitz et al.

References used by the students:

 Experiment No: 3

Compare the performances of linear search and binary search for Best case, Average case and
Worst case inputs.

Date:

Competency and Practical Skills: Algorithmic thinking, Programming Skills, Performance

analysis, and Mathematical skills

Relevant CO: CO1, CO2

Objectives: (a) Identify Best, Worst and Average cases of given problem.
(b) Derive time complexity from steps count for different inputs.

Equipment/Instruments: Computer System, Any C language editor

Theory:

Steps to implement linear search are as below:

A linear search, also known as a sequential search, is a method of finding an element within a list.
It checks each element of the list sequentially until a match is found or the whole list has been
searched. A simple approach to implement a linear search is:

1. Begin with the leftmost element of arr[] and one by one compare x with each element.
2. If x matches with an element, then return the index.
3. If x does not match with any of the elements, then return -1.

Steps to implement binary search are as below:

1. Take an input sorted array A of n elements and a target value T.

2. Define variables start and end to represent the start and end indices of the search range,
initially set to 0 and n-1 respectively.
3. Repeat the following steps while start <= end:
a. Calculate the midpoint index mid as (start + end) / 2.
b. If the value of the midpoint element A[mid] is equal to the target value T, return
the value of mid.
c. If the value of the midpoint element A[mid] is greater than the target value T, set
end to mid-1.
d. If the value of the midpoint element A[mid] is less than the target value T, set start
to mid+1.
4. If the target value T is not found in the array, return -1.
5. Output the value returned in Step 3, representing the position of the target value T in the array.
Implement function of linear search and binary search algorithm. Compare both the
algorithm on various inputs ranging from 100 to 500 for each case (Best, Average, and
Worst).
Observations:
Write observation based on time taken by both algorithms.

Result: Complete the below table based on your implementation of sequential search algorithm
and steps executed by the function.

Time taken (Best Case)

Inputs
Linear Search Binary Search
100
200
300
400
500
Time
Complexity

Prepare similar tables for Average case and Worst case of both algorithms.

Chart:
<Draw Comparative Charts of inputs versus time taken by both algorithms in various cases>

Conclusion:
Quiz:
1. Which element should be searched for the best case of binary search algorithm?
Answer:

2. Which element should be searched for the worst case of binary search algorithm?
Answer:

3. Which algorithm executes faster in worst case?

Answer:

Suggested Reference:
1. "Introduction to Algorithms" by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest,
and Clifford Stein
2. “Fundamentals of Algorithms” by E. Horowitz et al.

References used by the students:

 Experiment No: 4

Implement functions to print nth Fibonacci number using iteration and recursive method. Compare
the performance of two methods by time taken on various inputs. Also draw a comparative chart.
(Fibonacci series 1, 1, 2, 3, 5, 8….. Here 8 is the 6th Fibonacci number).

Date:

Competency and Practical Skills: Algorithmic thinking, Programming Skills, Performance

analysis

Relevant CO: CO1, CO5

Objectives: (a) Compare the performances of two different versions of same problem.
(b) Find the time complexity of algorithms.
(C) Understand the polynomial and non-polynomial problems

Equipment/Instruments: Computer System, Any C language editor

Theory:

The Fibonacci series is the sequence of numbers (also called Fibonacci numbers), where every
number is the sum of the preceding two numbers, such that the first two terms are '0' and '1'. In
some older versions of the series, the term '0' might be omitted. A Fibonacci series can thus be
given as, 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, . . . It can thus be observed that every term can be
calculated by adding the two terms before it. We are ignoring initial zero in the series.

To represent any (n+1) th term in this series, we can give the expression as, Fn = Fn-1 + Fn-2. We can
thus represent a Fibonacci series as shown in the image below,

Iterative version to print nth Fibonacci number is as below:

Input: An integer n, where n >= 1.
Output: The nth Fibonacci number.
Steps:
Initialize variables f0 = 1, f1 = 1, and i = 2.
If n is 1 or 2 then
Print 1
While i < n, do
a. Set f2 = f0 + f1.
b. Set f0 = f1.
c. Set f1 = f2.
d. Increment i by 1.
Print f1.
Recursive version to print nth Fibonacci number is as below:

Input: An integer n, where n >= 1.

Output: The nth Fibonacci number.
If n is 1 or 2 then
return 1.
else recursively compute next number using the (n-1) th and (n-2) th Fibonacci numbers, and return
their sum.
Print the result.
Implement functions of above two versions of Fibonacci series and compare the time taken
by both the functions on various inputs ranging from 10 to 50.
Observations:
Write observation based on time taken by both algorithms.

Result: Complete the below table based on your implementation of Iterative and Recursive
method and time taken by the function.

Time taken (Random data)

Inputs
Iterative Fibonacci Recursive Fibonacci
10
20
30

40

50
Time Complexity

Chart:
<Draw Comparative Charts of inputs versus time taken by both functions on various inputs>

Conclusion:

Quiz:
1. What is the time complexity of iterative version of Fibonacci function?
Answer:

2. What is the time complexity of recursive version of Fibonacci function?

Answer:

3. Can you execute recursive version of Fibonacci function for more inputs?
Answer:

4. What do you mean by polynomial time algorithms and exponential time algorithms?
Answer:

Suggested Reference:
1. "Introduction to Algorithms" by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest,
and Clifford Stein
2. “Fundamentals of Algorithms”by E. Horowitz et al.

References used by the students:

 Experiment No: 5

Implement program to solve problem of making a change using dynamic programming.

Date:

Competency and Practical Skills: Algorithmic thinking, Programming Skills, Problem solving

Relevant CO: CO3

Objectives: (a) Understand Dynamic programming algorithm design method.

(b) Solve the optimization based problem.
(c) Find the time complexity of the algorithm.

Equipment/Instruments: Computer System, Any C language editor

Theory:

Making Change problem is to find change for a given amount using a minimum number of coins
from a set of denominations. If we are given a set of denominations D = {d0, d1, d2, …, dn} and
if we want to change for some amount N, many combinations are possible. Suppose {d1, d2, d5,
d8}, {d0, d2, d4}, {d0, d5, d7} all are feasible solutions but the solution which selects the
minimum number of coins is considered to be an optimal solution. The aim of making a change is
to find a solution with a minimum number of coins / denominations. Clearly, this is an
optimization problem.

General assumption is that infinite coins are available for each denomination. We can select any
denomination any number of times.

Solution steps are as follow:

Sort all the denominations and start scanning from smallest to largest denomination. In every
iteration i, if current denomination di is acceptable, then 1 coin is added in solution and total
amount is reduced by amount di. Hence,
C[i, j] = 1 + (c [i, j – di])

C[i,j] is the minimum number of coins to make change for the amount j. Below figure shows the
content of matrix C.

Figure: Content of matrix C

using coins if current denomination is larger than current problem size, then we have to skip the
denomination and stick with previously calculated solution. Hence,
C[i, j] = C[i – 1, j]
If above cases are not applicable then we have to stick with choice which returns minimum
number of coin. Mathematically, we formulate the problem as,
C[i, j] = min {C[i – 1, j] , 1 + C[i, j – di]}

Steps to solve making change problem are as below:

Algorithm MAKE_A_CHANGE(d,N)
// d[1…n] = [d1,d2,…,dn] is array of n denominations
// C[1…n, 0…N] is n x N array to hold the solution of sub problems
// N is the problem size, i.e. amount for which change is required

for i ← 1 to n do
C[i, 0] ← 0
end
for i ← 1 to n do
for j ← 1 to N do
if i = = 1 ans j < d [i] then
C[i, j] ← ∞
else if i == 1 then
C[i, j] ← 1 + C[1, j – d[1])
else if j < d [i] then
C[i, j] ← C[I – 1, j]
else
C[i, j] ← min (C[i – 1, j] ,1 + C[i, j – d[i])
end
end
end
return C[n, N]
Implement above algorithm and print the matrix C. Your program should return the
number of coins required and its denominations.
Observations:
Write observation based on whether this algorithm returns optimal answer or not on various
inputs.

Result
Write output of your program

Conclusion:

Quiz:
1. What is the time complexity of above algorithm?
Answer:

2. Does above algorithm always return optimal answer?

Answer:

Suggested Reference:
1. "Introduction to Algorithms" by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest,
and Clifford Stein
2. “Fundamentals of Algorithms”by E. Horowitz et al.
3. https://codecrucks.com/making-change-problem-using-dynamic-programming/

References used by the students:

 Experiment No: 6

Implement program of chain matrix multiplication using dynamic programming.

Date:

Competency and Practical Skills: Algorithmic thinking, Programming Skills, Problem solving

Relevant CO: CO3

Objectives: (a) Understand Dynamic programming algorithm design method.

(b) Solve the optimization based problem.
(c) Find the time complexity of the algorithm.

Equipment/Instruments: Computer System, Any C language editor

Theory:

Given a sequence of matrices A1, A2,...,An and dimensions p0, p1,...,pn where Ai is of dimension pi−1
× pi, determine the order of multiplication (represented, say, as a binary tree) that minimizes the
number of operations.
This algorithm does not perform the multiplications; it just determines the best order in which to
perform the multiplications

Two matrices are called compatible only if the number of columns in the first matrix and the
number of rows in the second matrix are the same. Matrix multiplication is possible only if they
are compatible. Let A and B be two compatible matrices of dimensions p x q and q x r
Suppose dimension of three matrices are:

A1 = 5 x 4
A2 = 4 x 6
A3 = 6 x 2
Matrix multiplication is associative. So

(A1 A2) A3 = {(5 x 4) x (4 x 6)} x (6 x 2)

= (5 x 4 x 6) + (5 x 6 x 2)

= 180

A1 (A2 A3) = (5 x 4) x {(4 x 6) x (6 x 2)}

= (5 x 4 x 2) + (4 x 6 x 2)

= 88

The answer of both multiplication sequences would be the same, but the numbers of
multiplications are different. This leads to the question, what order should be selected for a chain
of matrices to minimize the number of multiplications?
Let us denote the number of alternative parenthesizations of a sequence of n matrices by p(n).
When n = 1, there is only one matrix and therefore only one way to parenthesize the matrix. When
n ≥ 2, a fully parenthesized matrix product is the product of two fully parenthesized matrix sub-
products, and the split between the two subproducts may occur between the k and (k +
1)st matrices for any k = 1, 2, 3…, n – 1. Thus we obtain the recurrence.

The solution to the recurrence is the sequence of Catalan numbers, which grows as Ω(4n / n3/2),
roughly equal to Ω(2n). Thus, the numbers of solutions are exponential in n. A brute force attempt
is infeasible to find the solution.

Any parenthesizations of the product Ai Ai + 1 … Aj must split the product between Ak and Ak+1 for
some integer k in the range i ≤ k < j. That is for some value of k, we first compute the matrices
Ai….k and Ak + 1…j and then multiply them together to produce the final product Ai…j The cost of
computing these parenthesizations is the cost of computing Ai….k , plus the cost of computing Ak +
1…j plus the cost of multiplying them together.

We can define m[i, j] recursively as follows. If i == j, the problem is trivial; the chain consists of
only one matrix Ai…i = A. No scalar multiplications are required. Thus m[i, i] = 0 for i = 1, 2 …n.
To compute m[i, j] when i < j, we take advantage of the structure of an optimal solution of the first
step. Let us assume that the optimal parenthesizations split the product Ai Ai + 1…Aj between
Ak and Ak + 1, where i ≤ k < j. Then m[i, j] is equal to the minimum cost for computing the
subproducts Ai…k and Ak + 1…j plus the cost of multiplying these two matrices together.

Where d = {d0, d1, d2, …, dn} is the vector of matrix dimensions.

m[i, j] = Least number of multiplications required to multiply matrix sequence Ai….Aj .
Steps to solve chain matrix multiplication problem are as below:
Algorithm MATRIX_CHAIN_ORDER(p)
// p is sequence of n matrices
n ← length(p) - 1
for i ← 1 to n do
m[i,i] ← 0
end
for l ← 2 to n do
for i ← 1 to n – l + 1 do
j←i+l-1
m[i, j] ← ∞
for k ← i to j – 1 do
q ← m[i, k]+ m[k + 1, j] + di – 1 * dk * dj
if q < m[i, j] then
m[i,j ] ← q
s[i, j] ← k
end
end
end
end
return m and s
Implement above algorithm and print the matrix m ans c.
Observations:
Write observation based on whether this algorithm returns optimal number of multiplications or
not on various inputs.

Result
Write output of your program

Conclusion:

Quiz:
1. What is the time complexity of above algorithm?
Answer:

2. Does above algorithm always return optimal answer?

Answer:

Suggested Reference:
1. "Introduction to Algorithms" by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest,
and Clifford Stein
2. “Fundamentals of Algorithms”by E. Horowitz et al.

References used by the students:

 Experiment No: 7
Implement program to solve LCS (Longest Common Subsequence) problem using dynamic
programing.

Date:

Competency and Practical Skills: Algorithmic thinking, Programming Skills, Problem solving

Relevant CO: CO3

Objectives: (a) Understand Dynamic programming algorithm design method.

(b) Solve the optimization based problem.
(c) Find the time complexity of the algorithm.

Equipment/Instruments: Computer System, Any C language editor

Theory:

The Longest Common Subsequence (LCS) problem is a classic computer science problem that
involves finding the longest subsequence that is common to two given sequences.

A subsequence is a sequence that can be derived from another sequence by deleting some or no
elements without changing the order of the remaining elements. For example, given the sequence
"ABCDE", "ACE" is a subsequence of "ABCDE", but "AEC" is not a subsequence.

Given two sequences X and Y, the LCS problem involves finding the longest common
subsequence (LCS) of X and Y. The LCS need not be contiguous in the original sequences, but it
must be in the same order. For example, given the sequences "ABCDGH" and "AEDFHR", the
LCS is "ADH" with length 3.

Naïve Method:

Let X be a sequence of length m and Y a sequence of length n. Check for every subsequence
of X whether it is a subsequence of Y, and return the longest common subsequence found. There
are 2m subsequences of X. Testing sequences whether or not it is a subsequence of Y takes O(n)
time. Thus, the naïve algorithm would take O(n2m) time.

longest common subsequence (LCS) using Dynamic Programming:

Let X=<x1,x2,x3....,xm> and Y=<y1,y2,y3....,ym> be the sequences. To compute the length of an
element the following algorithm is used.
Step 1 − Construct an empty adjacency table with the size, n × m, where n = size of
sequence X and m = size of sequence Y. The rows in the table represent the elements in sequence
X and columns represent the elements in sequence Y.
Step 2 − The zeroth rows and columns must be filled with zeroes. And the remaining values are
filled in based on different cases, by maintaining a counter value.
 Case 1 − If the counter encounters common element in both X and Y sequences, increment
the counter by 1.
 Case 2 − If the counter does not encounter common elements in X and Y sequences at T[i,
j], find the maximum value between T[i-1, j] and T[i, j-1] to fill it in T[i, j].
Step 3 − Once the table is filled, backtrack from the last value in the table. Backtracking here is
done by tracing the path where the counter incremented first.
Step 4 − The longest common subseqence obtained by noting the elements in the traced path.
Consider the example, we have two strings X=BDCB and Y=BACDB to find the longest common
subsequence. Following table shows the construction of LCS table.

Once the values are filled, the path is traced back from the last value in the table at T[5, 4].

Algorithm is as below:

Algorithm: LCS-Length-Table-Formulation (X, Y)

m := length(X)
n := length(Y)
for i = 1 to m do
C[i, 0] := 0
for j = 1 to n do
C[0, j] := 0
for i = 1 to m do
for j = 1 to n do
if xi = yj
C[i, j] := C[i - 1, j - 1] + 1
B[i, j] := ‘D’
else
if C[i -1, j] ≥ C[i, j -1]
C[i, j] := C[i - 1, j] + 1
B[i, j] := ‘U’
else
C[i, j] := C[i, j - 1] + 1
 B[i, j] := ‘L’
return C and B

Algorithm: Print-LCS (B, X, i, j)

if i=0 and j=0
return
if B[i, j] = ‘D’
Print-LCS(B, X, i-1, j-1)
Print(xi)
else if B[i, j] = ‘U’
Print-LCS(B, X, i-1, j)
else
Print-LCS(B, X, i, j-1)
Implement program to solve LCS (Longest Common Subsequence) problem using dynamic
programing.
Observations:
Write observation based on whether this algorithm returns optimal answer or not on various
inputs.

Result
Write output of your program

Conclusion:

Quiz:
1. What is the time complexity of above algorithm?
Answer:

2. Does above algorithm always return optimal answer?

Answer:

3. Does Dynamic programming approach to find LCS perform well compare to naïve approach?
Answer:

Suggested Reference:
1. "Introduction to Algorithms" by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest,
and Clifford Stein
2. “Fundamentals of Algorithms”by E. Horowitz et al.

References used by the students:

 Experiment No: 8
Implement program to solve Knapsack problem using dynamic programming.

Date:

Competency and Practical Skills: Algorithmic thinking, Programming Skills, Problem solving

Relevant CO: CO3

Objectives: (a) Understand Dynamic programming algorithm design method.

(b) Solve the optimization based problem.
(c) Find the time complexity of the algorithm.

Equipment/Instruments: Computer System, Any C language editor

Theory:

Knapsack problem is as stated below:

Given a set of items, each having different weight and value or profit associated with it. Find the
set of items such that the total weight is less than or equal to a capacity of the knapsack and the
total value earned is as large as possible.

The knapsack problem is useful in solving resource allocation problem. Let X = < x1, x2, x3, . . . . .
, xn> be the set of n items. Sets W = <w1, w2, w3, . . . , wn> and V = < v1, v2, v3, . . . , vn> are weight
and value associated with each item in X. Knapsack capacity is M unit.
The knapsack problem is to find the set of items which maximizes the profit such that collective
weight of selected items does not cross the knapsack capacity. Select items from X and fill the
knapsack such that it would maximize the profit.
Knapsack problem has two variations. 0/1 knapsack, that does not allow breaking of items. Either
add an entire item or reject it. It is also known as a binary knapsack. Fractional knapsack allows
breaking of items. Profit will be earned proportionally.
Following are the steps to implement binary knapsack using dynamic programming.

Algorithm DP_BINARY_KNAPSACK (V, W, M)

// Description: Solve binary knapsack problem using dynamic programming
// Input: Set of items X, set of weight W, profit of items V and knapsack capacity M
// Output: Array V, which holds the solution of problem
for i ← 1 to n do
V[i, 0] ← 0
end
for i ← 1 to M do
V[0, i] ← 0
end
for V[0, i] ← 0 do
for j ← 0 to M do
if w[i] ≤ j then
V[i, j] ← max{V[i-1, j], v[i] + V[i – 1, j – w[i]]}
else
 V[i, j] ← V[i – 1, j] // w[i]>j
end
end
end

The above algorithm will just tell us the maximum value we can earn with dynamic programming.
It does not speak anything about which items should be selected. We can find the items that give
optimum result using the following algorithm.

Algorithm TRACE_KNAPSACK(w, v, M)
// w is array of weight of n items
// v is array of value of n items
// M is the knapsack capacity
SW ← { }
SP ← { }
i←n
j←M
while ( j> 0 ) do
if (V[i, j] == V[i – 1, j]) then
i←i–1
else
V[i, j] ← V[i, j] – vi
j ← j – w[i]
SW ← SW +w[i]
SP ← SP +v[i]
end
end
Implement program to solve Knapsack problem using dynamic programming.
Observations:
Write observation based on whether this algorithm returns optimal answer or not on various
inputs.

Result
Write output of your program

Conclusion:

Quiz:
1. What is the time complexity of above binary knapsack algorithm?
Answer:

2. Does above algorithm always return optimal answer?

Answer:

Suggested Reference:
1. "Introduction to Algorithms" by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest,
and Clifford Stein
2. “Fundamentals of Algorithms”by E. Horowitz et al.

References used by the students:

 Experiment No: 9
Implement program for solution of fractional Knapsack problem using greedy design technique.

Date:

Competency and Practical Skills: Algorithmic thinking, Programming Skills, Problem solving

Relevant CO: CO3

Objectives: (a) Understand greedy algorithm design method.

(b) Solve the optimization based problem.
(c) Find the time complexity of the algorithm.

Equipment/Instruments: Computer System, Any C language editor

Theory:
Knapsack problem is as stated below:
Given a set of items, each having different weight and value or profit associated with it. Find the
set of items such that the total weight is less than or equal to a capacity of the knapsack and the
total value earned is as large as possible.
Brute-force approach: The brute-force approach tries all the possible solutions with all the
different fractions but it is a time-consuming approach.
Greedy approach: In Greedy approach, we calculate the ratio of profit/weight, and accordingly, we
will select the item. The item with the highest ratio would be selected first.
Following are the steps to implement fractional knapsack using greedy design strategy.

1. Compute the value-to-weight ratio for each item in the knapsack.

2. Sort the items in decreasing order of value-to-weight ratio.
3. Initialize the total weight and total value to 0.
4. For each item in the sorted list:
a. If the entire item can be added to the knapsack without exceeding the weight
capacity, add it and update the total weight and total value.
b. If the item cannot be added entirely, add a fraction of the item that fits into the
knapsack and update the total weight and total value accordingly.
c. If the knapsack is full, stop the algorithm.
5. Return the total value and the set of items in the knapsack.
Implement the program based on above logic for the solution of fractional knapsack
problem.
Observations:
Write observation based on whether this algorithm returns optimal answer or not on various
inputs.

Result
Write output of your program

Conclusion:

Quiz:
1. What is the time complexity of above knapsack algorithm?
Answer:

2. Does above algorithm always return optimal answer?

Answer:

3. What is the time complexity solving knapsack problem using brute-force method?
Answer:

Suggested Reference:
1. "Introduction to Algorithms" by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest,
and Clifford Stein
2. “Fundamentals of Algorithms”by E. Horowitz et al.

References used by the students:

 Experiment No: 10
Implement program for solution of Making Change problem using greedy design technique.

Date:

Competency and Practical Skills: Algorithmic thinking, Programming Skills, Problem solving

Relevant CO: CO3

Objectives: (a) Understand greedy algorithm design method.

(b) Solve the optimization based problem.
(c) Find the time complexity of the algorithm.

Equipment/Instruments: Computer System, Any C language editor

Theory:

Making Change problem is to find change for a given amount using a minimum number of coins
from a set of denominations. If we are given a set of denominations D = {d0, d1, d2, …, dn} and if
we want to change for some amount N, many combinations are possible. {d1, d2, d5, d8}, {d0, d2,
d4}, {d0, d5, d7} can be considered as all feasible solutions if sum of their denomination is N. The
aim of making a change is to find a solution with a minimum number of coins / denominations.
Following are the steps to solve coin change problem using greedy design technique

1. Initialize a list of coin denominations in descending order.

2. Initialize a list of coin counts, where each count is initially 0.
3. While the remaining amount is greater than 0:
a. For each coin denomination in the list:
i. If the denomination is less than or equal to the remaining amount, add one
coin to the count and subtract the denomination from the remaining
amount.
ii. If the denomination is greater than the remaining amount, move on
to the next denomination.
4. Return the list of coin counts.
Implement the program based on above steps for the solution of fractional knapsack
problem.
Observations:
Write observation based on whether this algorithm returns optimal answer or not on various
inputs.

Result
Write output of your program

Conclusion:

Quiz:
1. What is the time complexity of above knapsack algorithm?
Answer:

2. Does above algorithm always return optimal answer?

Answer:

3. What are some variations of the Making Change problem?

Answer:

4. What is the difference between the unbounded coin change problem and the limited coin
change problem?
Answer:

Suggested Reference:
1. "Introduction to Algorithms" by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest,
and Clifford Stein
2. “Fundamentals of Algorithms”by E. Horowitz et al.

References used by the students:

 Experiment No: 11
Implement program for Kruskal's algorithm to find minimum spanning tree.

Date:

Competency and Practical Skills: Algorithmic thinking, Programming Skills, Problem solving

Relevant CO: CO3, CO6

Objectives: (a) Understand how to use Kruskal's algorithm to find the minimum spanning tree.
(b) Solve the optimization based problem.
(c) Find the time complexity of the algorithm.

Equipment/Instruments: Computer System, Any C language editor

Theory:

In graph theory, a minimum spanning tree (MST) of an undirected, weighted graph is a tree that
connects all the vertices of the graph with the minimum possible total edge weight. In other
words, an MST is a subset of the edges of the graph that form a tree and have the smallest sum of
weights.

1. Sort all the edges in non-decreasing order of their weight.

2. Initialize an empty set of edges for the minimum spanning tree.
3. For each edge in the sorted order, add the edge to the minimum spanning tree if it does not
create a cycle in the tree. To check if adding the edge creates a cycle, you can use the Union-
Find algorithm or a similar method to keep track of the connected components of the graph.
4. Continue adding edges until there are V-1 edges in the minimum spanning tree, where V is the
number of vertices in the graph.
5. Return the set of edges in the minimum spanning tree.
6. Implement the program based on above steps for the solution of fractional knapsack problem.

Kruskal’s Algorithm is as follow:

Implement program for Kruskal's algorithm to find minimum spanning tree.
Observations:
Write observation based on whether this algorithm always returns minimum spanning tree or not
on various inputs.

Result
Write output of your program

Conclusion:

Quiz:
1. What is the time complexity of krushkal’s algorithm?
Answer:

2. Does above krushkal’s algorithm always return optimal answer?

Answer:

3. What data structure is typically used to keep track of the connected components in Kruskal's
algorithm?
Answer:

4. When does Kruskal's algorithm stop adding edges to the minimum spanning tree?
Answer:

Suggested Reference:
1. "Introduction to Algorithms" by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest,
and Clifford Stein
2. “Fundamentals of Algorithms”by E. Horowitz et al.

References used by the students:

 Experiment No: 12
Implement program for Prim's algorithm to find minimum spanning tree.

Date:

Competency and Practical Skills: Algorithmic thinking, Programming Skills, Problem solving

Relevant CO: CO3, CO6

Objectives: (a) Understand how to use Prim's algorithm to find the minimum spanning tree.
(b) Solve the optimization based problem.
(c) Find the time complexity of the algorithm.

Equipment/Instruments: Computer System, Any C language editor

Theory:

In graph theory, a minimum spanning tree (MST) of an undirected, weighted graph is a tree that
connects all the vertices of the graph with the minimum possible total edge weight. In other
words, an MST is a subset of the edges of the graph that form a tree and have the smallest sum of
weights.

Prim’s Algorithm is as follow:

Implement program for Prim's algorithm to find minimum spanning tree.
Observations:
Write observation based on whether this algorithm always returns minimum spanning tree or not
on various inputs.

Result
Write output of your program

Conclusion:

Quiz:
1. What is the time complexity of Prim’s algorithm?
Answer:

2. Does above Prim’s algorithm always return optimal answer?

Answer:

3. When does Prim's algorithm stop adding edges to the minimum spanning tree?
Answer:

4. What data structure is typically used to keep track of the vertices in Prim's algorithm?
Answer:

Suggested Reference:
1. "Introduction to Algorithms" by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest,
and Clifford Stein
2. “Fundamentals of Algorithms”by E. Horowitz et al.

References used by the students:

 Experiment No: 13
Implement DFS and BFS graph traversal techniques and write its time complexities.

Date:

Competency and Practical Skills: Algorithmic thinking, Programming Skills, Problem solving

Relevant CO: CO6

Objectives: (a) Understand Graph traversal techniques.

(b) Visit all nodes of the graph.
(c) Find the time complexity of the algorithm.

Equipment/Instruments: Computer System, Any C language editor

Theory:

Depth First Search is a graph traversal algorithm that explores as far as possible along each branch
before backtracking. It is used to search for a node or a path in a graph, and is implemented
recursively or iteratively.
The algorithm starts at a specified node and visits all the nodes in the graph by exploring each
branch as far as possible before backtracking to the previous node. When a node is visited, it is
marked as visited to prevent loops.

Consider the following steps for the implementation of DFS algorithm:

1. Create an empty stack and push the starting node onto it.
2. Mark the starting node as visited.
3. While the stack is not empty, pop a node from the stack and mark it as visited.
4. For each adjacent node to the current node, if the adjacent node has not been visited, mark it
as visited and push it onto the stack.
5. After processing all the adjacent nodes, you can do something with the current node, such as
printing it or storing it.
6. Repeat steps 3 to 5 until the stack is empty.

Consider the following steps for the implementation of BFS algorithm:

1. Create a queue Q and a set visited.

2. Add the starting node to the queue Q and mark it as visited.
3. While the queue is not empty:
a. Dequeue a node from the queue Q and process it.
b. For each adjacent node of the dequeued node:
i. If the adjacent node has not been visited, mark it as visited and enqueue it into
the queue Q.
Implement DFS and BFS graph traversal techniques and write its time complexities.
Observations:
Write observation based on output of algorithm that which node of graph is traversed first in BFS
and DFS.
Result
Write output of your program

Conclusion:

Quiz:
1. What data structure is typically used in the iterative implementation of DFS and BFS?
Answer:

2. What is the time complexity of DFS on a graph with V vertices and E edges?
Answer:

3. What is the time complexity of BFS on a graph with V vertices and E edges?
Answer:

4. In which order are nodes visited in a typical implementation of BFS?

Answer:

Suggested Reference:
1. "Introduction to Algorithms" by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest,
and Clifford Stein
2. “Fundamentals of Algorithms”by E. Horowitz et al.

References used by the students:

 Experiment No: 14
Implement Rabin-Karp string matching algorithm.

Date:

Competency and Practical Skills: Algorithmic thinking, Programming Skills, Problem solving

Relevant CO: CO4

Objectives: (a) Find all occurrences of a pattern in a given text.

(b) Improve the performance of the brute force algorithm.
(c) Find a pattern in a given text with less time complexity in the average case.

Equipment/Instruments: Computer System, Any C language editor

Theory:
It is a string searching algorithm that is named after its authors Richard M. Carp and Michael O.
Rabin. This algorithm is used to find all the occurrences of a given pattern ‘P’’ in a given string
‘S’ in O(Ns + Np) time in average case, where ‘Ns’ and ‘Np’ are the lengths of ‘S’’ and ‘P’,
respectively.

Let’s take an example to make it more clear.

Assume the given string S = “cxyzghxyzvjkxyz” and pattern P = “xyz” and we have to find all the
occurrences of ‘P’ in ‘S’.

We can see that “xyz” is occurring in “cxyzghxyzvjkxyz” at three positions. So, we have to print
that pattern ‘P’ is occurring in string ‘S’ at indices 1, 6, and 12.

Naive Pattern Searching (brute force) algorithm slides the pattern over text one by one and checks
for a match. If a match is found, then slide by 1 again to check for subsequent matches. This
approach has a time complexity of O(P* (S-P)).

The Rabin-Karp algorithm starts by computing, at each index of the text, the hash value of the
string starting at that particular index with the same length as the pattern. If the hash value of that
equals to the hash value of the given pattern, then it does a full match at that particular index.

Rabin Karp algorithm first computes the hash value of pattern P and first Np characters from S. If
hash values are same, we check the equality of actual strings. If the pattern is found, then it is
called hit. Otherwise, it is called a spurious hit. If hash values are not same, no need to compare
actual strings.

Steps of Rabin-Karp algorithm are as below:

1. Calculate the hash value of the pattern: The hash value of the pattern is calculated using a hash
function, which takes the pattern as input and produces a hash value as output.
2. Calculate the hash values of all the possible substrings of the same length in the text: The hash
values of all the possible substrings of the same length as the pattern are calculated using the
same hash function.
3. Compare the hash value of the pattern with the hash values of all the possible substrings: If a
match is found, the algorithm checks the characters of the pattern and the substring to verify
that they are indeed equal.
4. Move on to the next possible substring: If the characters do not match, the algorithm moves on
to the next possible substring and repeats the process until all possible substrings have been
compared.
Implement the Rabin-Karp algorithm based on above steps and give different input text and
pattern to check its correctness. Also, find the time complexity of your implemented
algorithm.
Observations:
Write observation based on whether this algorithm able to find a pattern in a given text or not and
find it’s time complexity in worst case and average case based on its way of working.

Result
Write output of your program

Conclusion:

Quiz:
1. What is the Rabin-Karp algorithm used for?
Answer:

2. What is the time complexity of the Rabin-Karp algorithm in the average case?
Answer:

3. What is the main advantage of the Rabin-Karp algorithm over the brute force algorithm for
string matching?
Answer:

4. What is the worst-case time complexity of the Rabin-Karp algorithm?

Answer:

Suggested Reference:
1. "Introduction to Algorithms" by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest,
and Clifford Stein
2. “Fundamentals of Algorithms”by E. Horowitz et al.

References used by the students: