DEPARTMENT OF CSE-ARTIFICIAL ENGINEERING

ANALYSYS AND DESIGN OF ALGORITHMS LABORATORY MANUAL

BCSL404

PREPARED BY:

PRATHIBHA A
Assistant Professor
Department of CSE-AI
SVCE,Bangalore

1
VISION :
Promoting prosperity of mankind by augmenting human resource capital through Quality Technical Education
and training in Artificial Intelligence Department.
MISSION:
The mission of Artificial Intelligence is to accomplish excellence in the field of Artificial Intelligence technical
education through education, research and service needs of society. And also to educate students in the area of
artificial intelligence by providing best practices of teaching learning process for careers in software are industry
or higher education.
M1: For acquiring the new skills and technology of artificial technology in software field and research field.
M2: To be a model center for education and training in the frontier areas of education by quality technical
education and training.
M3: To get excellence in the technical education through education, research and service needed by the society.

PROGRAMME OUTCOMES

Engineering graduates in Computer Science and Engineering will be able to:

 Engineering knowledge: Apply the knowledge of mathematics, science, engineering fundamentals

and an engineering specialization to the solution of complex engineering problems.
 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.
 Design/development of solutions: Design solutions for complex engineering problems and design
system components or processes that meet the specific needs with appropriate consideration for the
public health and safety, and the cultural, societal and environmental considerations.
 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 informationto
provide valid conclusions.
 Modern tool usage: Select/Create and apply appropriate techniques, resources and modern
engineering and IT tools, including prediction and modeling to complex engineering activities,
taking comprehensive cognizance of their limitations.
 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.

 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.
 Ethics: Apply ethical principles and commit to professional ethics and responsibilities and norms of
the relevant scientific and/or engineering practices.
2
  Individual and team work: Function effectively as an individual and as a member or leader indiverse
teams and in multi disciplinary settings.
 Communication: Communicate effectively on complex engineering activities with the engineering
community and with the 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.
 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 tomanage
projects and in multidisciplinary environments.
 Life-long learning: Recognize the need for and above have the preparation and ability to engage in
independent and life-long learning in the broadcast context of technological changes.

PROGRAM SPECFIC OBJECTIVES-PSOS

PEO1 Graduates will have solid basics in Mathematics, Programming, Machine Learning, Artificial Intelligence
and Data Science fundamentals and advancements to solve technical problems.

PEO2 Graduates will have the capability to apply their knowledge and skills acquired to solve the issues in real
world Artificial Intelligence and Data Science sectors and to develop feasible and viable systems.

PEO3 Graduates will have the potential to participate in life-long learning through the successful completion of
advanced degrees, continuing education, certifications and/or other professional developments.

PEO4 Graduates will have the ability to apply the gained knowledge to improve the society ensuring ethical
and moral values.

Course Objectives:

This laboratory course enables students to get practical experience in design, develop,
implement, analyze and evaluation/testing of

 To design and implement various algorithms in C/C++ programming using suitable

development tools to address different computational challenges.

● To apply diverse design strategies for effective problem-solving.

● To Measure and compare the performance of different algorithms to determine their efficiency
and suitability for specific tasks.

Course Outcomes (Course Skill Set)

At the end of the course the student will be able to:
1. Develop programs to solve computational problems using suitable algorithm design
strategy.
3
 2. Compare algorithm design strategies by developing equivalent programs and observing
running times for analysis (Empirical).
3. Make use of suitable integrated development tools to develop programs
4. Choose appropriate algorithm design techniques to develop solution to the computational
and complex problems.
5. Demonstrate and present the development of program, its execution and running time(s)
and record the results/inferences.

4
 SYLLABUS
[Link]. DETAILS HOURS

Design and implement C/C++ Program to find Minimum Cost

1 Spanning Tree of a given connected undirected graph using 2
Kruskal's algorithm.
Design and implement C/C++ Program to find Minimum Cost
2 Spanning Tree of a given connected undirected graph using Prim's 2
algorithm.
a. Design and implement C/C++ Program to solve All-Pairs Shortest
Paths problem using Floyd's algorithm.

3 b. Design and implement C/C++ Program to find the transitive 2

closure using Warshal's algorithm.
Design and implement C/C++ Program to find shortest paths from a
4 given vertex in a weighted connected graph to other vertices using
Dijkstra's algorithm. 2
Design and implement C/C++ Program to obtain the Topological
5 ordering of vertices in a given digraph. 2
Design and implement C/C++ Program to solve 0/1 Knapsack
6 problem using Dynamic Programming method. 2
Design and implement C/C++ Program to solve discrete Knapsack
7 and continuous Knapsack problems using greedy approximation 2
method.
Design and implement C/C++ Program to find a subset of a given set
8 S = {sl , s2,.....,sn} of n positive integers whose sum is equal to a given 2
positive integer d.

Design and implement C/C++ Program to sort a given set of n integer

elements using Selection Sort method and compute its time 2
9 complexity. Run the program for varied values of n> 5000 and
record the time taken to sort. Plot a graph of the time taken versus n.
The elements can be read from a file or can be generated using the
random number generator. with appropriate functions for each of the
above operations

Design and implement C/C++ Program to sort a given set of n integer

elements using Quick Sort method and compute its time complexity. 2
10 Run the program for varied values of n> 5000 and record the time
taken to sort. Plot a graph of the time taken versus n. The elements
can be read from a file or can be generated using the random
number generator.

5
 Design and implement C/C++ Program to sort a given set of n integer
11 elements using Merge Sort method and compute its time complexity. 2
Run the program for varied values of n> 5000, and record the time
taken to sort. Plot a graph of the time taken versus n. The elements
can be read from a file or can be generated using the random number
generator.
12 Design and implement C/C++ Program for N Queen's problem using
Backtracking. 2

TOTAL HOURS 24

6
PROGRAM 1:
Design and implement C/C++ Program to find Minimum Cost Spanning Tree of a given
connected undirected graph using Kruskal's algorithm.

Aim : To apply Kruskal's Algorithm for computing the minimum spanning tree is directly based on the generic
MST algorithm. It builds the MST in forest.

Definition: Kruskal’s algorithm is an algorithm in graph theory that finds a minimum spanning tree for a connected weighted
graph. This mean it finds a subset of the edges that forms a tree that includes every vertex, where the total weight of all the
edges in the tree is minimized. If the graph is not connected, then it finds a minimum spanning forest. It is an example of a
greedy algorithm.
Efficiency: With an efficient sorting algorithm, the time efficiency of Kruskal’s algorithm will be in O(│E│log│E│)

Algorithm

Start with an empty set A, and select at every stage the shortest edge that has not been chosen or rejected, regardless
of where this edge is situated in graph.

 Initially, each vertex is in its own tree in forest.

 Then, algorithm consider each edge in turn, order by increasing weight.

 If an edge (u, v) connects two different trees, then (u, v) is added to the set of edges of the MST, and two
trees connected by an edge (u, v) are merged into a single tree.

 On the other hand, if an edge (u, v) connects two vertices in the same tree, then edge (u, v) is discarded.

Kruskals algorithm can be implemented using disjoint set data structure or priority queue data structure.

I Kruskal's algorithm implemented with disjoint-sets data structure.

MST_KRUSKAL (G, w)

1. A ← {} // A will ultimately contains the edges of the MST

2. for each vertex v in V[G]
3. do Make_Set (v)
4. Sort edge of E by nondecreasing weights w
5. for each edge (u, v) in E
6. do if FIND_SET (u) ≠ FIND_SET (v)
7. then A = AU{(u, v)}
8. UNION (u, v)
9. Return A

7
 PROGRAM

#define INF 999

#define MAX 100
int p[MAX], c[MAX][MAX], t[MAX][2];
int find(int v)
{
while (p[v])
v = p[v];
return v;
}
void union1(int i, int j)
{
p[j] = i;
}
void kruskal(int n)
{
int i, j, k, u, v, min, res1, res2, sum = 0;
for (k = 1; k < n; k++)
{
min = INF;
for (i = 1; i < n - 1; i++)
{
for (j = 1; j <= n; j++)
{
if (i == j) continue;
if (c[i][j] < min)
{
u = find(i);
v = find(j);
if (u != v)
{
res1 = i;
res2 = j;
min = c[i][j];
}
}
}
}
union1(res1, find(res2));
8
 t[k][1] = res1;
t[k][2] = res2;
sum = sum + min;
}
printf("\nCost of spanning tree is=%d", sum);
printf("\nEdgesof spanning tree are:\n");
for (i = 1; i < n; i++)
printf("%d -> %d\n", t[i][1], t[i][2]);
}
int main()
{
int i, j, n;
printf("\nEnter the n value:");
scanf("%d", & n);
for (i = 1; i <= n; i++)
p[i] = 0;
printf("\nEnter the graph data:\n");
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
scanf("%d", & c[i][j]);
kruskal(n);
return 0;
}

OUTPUT

Enter the n value:5

Enter the graph data:

13462
17693
5 2 8 99 45
1 44 66 33 6
12 4 3 2 0
Cost of spanning tree is=11
Edges of spanning tree are:
2 -> 1
1 -> 5
3 -> 2
1 -> 4
9
PROGRAM 2:

Design and implement C/C++ Program to find Minimum Cost Spanning Tree of a given connected
undirected graph using Prim's algorithm.

Aim:To find minimum spanning tree of a given graph using prim’s algorithm

Definition: Prim’s is an algorithm that finds a minimum spanning tree for a connected weighted undirected graph. This means
it finds a subset of the edges that forms a tree that includes every vertex, where the total weight of all edges in the tree is
minimized. Prim’s algorithm is an example of a greedy algorithm.

Algorithm

MST_PRIM (G, w, v)

1. Q ← V[G]
2. for each u in Q do
3. key [u] ← ∞
4. key [r] ← 0
5. π[r] ← NIl
6. while queue is not empty do
7. u ← EXTRACT_MIN (Q)
8. for each v in Adj[u] do
9. if v is in Q and w(u, v) < key [v]
10. then π[v] ← w(u, v)
11. key [v] ← w(u, v)

PROGRAM:

#include<stdio.h>
#define INF 999
int prim(int c[10][10],int n,int s)
{
int v[10],i,j,sum=0,ver[10],d[10],min,u;
for(i=1; i<=n; i++)
{
ver[i]=s;
d[i]=c[s][i];
v[i]=0;
}
v[s]=1;
for(i=1; i<=n-1; i++)
10
 {
min=INF;
for(j=1; j<=n; j++)
if(v[j]==0 && d[j]<min)
{
min=d[j];
u=j;
}
v[u]=1;
sum=sum+d[u];
printf("\n%d -> %d sum=%d",ver[u],u,sum);
for(j=1; j<=n; j++)
if(v[j]==0 && c[u][j]<d[j])
{
d[j]=c[u][j];
ver[j]=u;
}
}
return sum;
}
void main()
{
int c[10][10],i,j,res,s,n;
printf("\nEnter n value:");
scanf("%d",&n);
printf("\nEnter the graph data:\n");
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
scanf("%d",&c[i][j]);
printf("\nEnter the souce node:");
scanf("%d",&s);
res=prim(c,n,s);
printf("\nCost=%d",res);
getch();}

11
OUTPUT:

Enter n value:4

Enter the graph data:

4521
7592
1769
0285

Enter the souce node:4

4 -> 1 sum=0
4 -> 2 sum=2
1 -> 3 sum=4
Cost=4

12
PROGRAM 3:

a. Design and implement C/C++ Program to solve All-Pairs Shortest Paths problem using Floyd's algorithm.

b. Design and implement C/C++ Program to find the transitive closure using Warshal's
algorithm.

Definition: The Floyd algorithm is a graph analysis algorithm for finding shortest paths in a weighted graph (with positive or
negative edge weights). A single execution of the algorithm will find the lengths (summed weights) of the shortest paths
between all pairs of vertices though it does not return details of the paths themselves. The algorithm is an example of dynamic
programming.

Algorithm:
Floyd’s Algorithm
Accept no .of vertices
Call graph function to read weighted graph // w(i,j)
Set D[ ] <- weighted graph matrix // get D {d(i,j)} for k=0
// If there is a cycle in graph, abort. How to find?
Repeat for k = 1 to n
Repeat for i = 1 to n
Repeat for j = 1 to n
D[i,j] = min {D[i,j], D[i,k] + D[k,j]}
Print D

PROGRAM

#include<stdio.h>
#include<conio.h>
#define INF 999
int min(int a,int b)
{
return(a<b)?a:b;}
13
 void floyd(int p[][10],int n)
{
int i,j,k;
for(k=1; k<=n; k++)
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
p[i][j]=min(p[i][j],p[i][k]+p[k][j]);
}
void main()
{
int a[10][10],n,i,j;
printf("\nEnter the n value:");
scanf("%d",&n);
printf("\nEnter the graph data:\n");
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
scanf("%d",&a[i][j]);
floyd(a,n);
printf("\nShortest path matrix\n");
for(i=1; i<=n; i++)
{
for(j=1; j<=n; j++)
printf("%d ",a[i][j]);
printf("\n");
}
getch();
}

OUTPUT:
Enter the n value:4
Enter the graph data:
0 999 3 999
2 0 999 999
999 7 0 1
6 999 999 0
Shortest path matrix
0 10 3 4
2056
7701
6 16 9 0
14
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)

PROGRAM 3 B:

Definition:The Floyd-Warshall algorithm is a graph analysis algorithm for finding shortest paths in a weighted graph. A
single execution of the algorithm will find the lengths of the shortest path between all pairs of vertices though it does not
return details of the paths themselves. The algorithm is an example of Dynamic programming.

Algorithm
//Input: Adjacency matrix of digraph
//Output: R, transitive closure of digraph
Accept no .of vertices
Call graph function to read directed graph
Set R[ ] <- digraph matrix // get R {r(i,j)} for k=0
Print digraph
Repeat for k = 1 to n
Repeat for i = 1 to n
Repeat for j = 1 to n
R(i,j) = 1 if
{rij(k-1) = 1 OR
rik(k-1) = 1 and rkj(k-1) = 1}
Print R

PROGRAM:

#include<stdio.h>
void warsh(int p[][10],int n)
{
int i,j,k;
for(k=1; k<=n; k++)
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
p[i][j]=p[i][j] || p[i][k] && p[k][j];
}
int main()
{
int a[10][10],n,i,j;
printf("\nEnter the n value:");
15
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
scanf("%d",&n);
printf("\nEnter the graph data:\n");
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
scanf("%d",&a[i][j]);
warsh(a,n);
printf("\nResultant path matrix\n");
for(i=1; i<=n; i++)
{
for(j=1; j<=n; j++)
printf("%d ",a[i][j]);
printf("\n");
}
return 0;
}

OUTPUT

Enter the n value:4Enter the graph data:

0100
0001
0000
1 0 1 0Resultant path matrix
1111
1111
0000
1111

16
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)

PROGRAM 4:

Design and implement C/C++ Program to find shortest paths from a given vertex in a weighted
connected graph to other vertices using Dijkstra's algorithm.

Aim:To find shortest path using Dijikstra’s algorithm.

Definition: Dijikstra’s algorithm -For a given source vertex(node) in the graph, the algorithm finds the path with lowest cost
between that vertex and every other vertex. It can also be used for finding cost of shortest paths from a single vertex to a
single destination vertex by stopping the algorithm once the shortest path to the destination vertex has been determined.
2
Efficiency:1) )-graph represented by weighted matrix and priority queue as unordered array
2)O(│E│log│v│)-graph represented by adjacency lists and priority queue as min-heap

Algorithm: Dijikstra(G,s)
//Dijikstra’s algorithm for single source shortest path
//input:A weighted connected graph with non negative weights and its vertex s
//output:The length dv of a shortest path from s to v and penultimate vertex p v for every vertex v in V
Initialize(Q)
for every vertex v in V do
dv<-∞;Pv<-null
Insert(Q,v,dv)
Ds<-0; Decrease(Q,s,ds);VT<-ǿ
for i<- 0 to │V│-1 do
u*<-DeleteMin(Q)
VT<-VT U{u*}
For every vertex u in V-VT that is adjacent to u* do
If du*+w(u*,u)<du
du<- du*+w(u*,u); pu<-u*
Decrease(Q,u,du)

17
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
PROGRAM :

#include<stdio.h>

#define INF 999

void dijkstra(int c[10][10],int n,int s,int d[10])

int v[10],min,u,i,j;

for(i=1; i<=n; i++)

d[i]=c[s][i];

v[i]=0;

v[s]=1;

for(i=1; i<=n; i++)

min=INF;

for(j=1; j<=n; j++)

if(v[j]==0 && d[j]<min)

min=d[j];

u=j;

18
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
v[u]=1;

for(j=1; j<=n; j++)

if(v[j]==0 && (d[u]+c[u][j])<d[j])

d[j]=d[u]+c[u][j];

int main()

int c[10][10],d[10],i,j,s,sum,n;

printf("\nEnter n value:");

scanf("%d",&n);

printf("\nEnter the graph data:\n");

for(i=1; i<=n; i++)

for(j=1; j<=n; j++)

scanf("%d",&c[i][j]);

printf("\nEnter the souce node:");

scanf("%d",&s);

dijkstra(c,n,s,d);

for(i=1; i<=n; i++)

printf("\nShortest distance from %d to %d is %d",s,i,d[i]);

return 0;}

19
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)

OUTPUT:

Enter n value:4

Enter the graph data:

444 767 987 12
999 87 56 45
1 0 999 678
444 678 235 0

Enter the souce node:1

Shortest distance from 1 to 1 is 444

Shortest distance from 1 to 2 is 247
Shortest distance from 1 to 3 is 247
Shortest distance from 1 to 4 is 12

20
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)

PROGRAM 5:

Design and implement C/C++ Program to obtain the Topological ordering of vertices in a
given digraph.

Aim:To find topological ordering of given graph

Definition:Topological ordering that for every edge in the graph,the vertex where the edge starts is listed
before the edge where the edge ends.
Algorithm:
[Link] identify in a remaining digraph a source which is a vertex with no incoming edges and delete it
along with all edges outgoing from it
[Link] order in which the vertices are deleted yields a solution to the topological sorting.

#include<stdio.h>
#include<conio.h>
int temp[10],k=0;
void sort(int a[][10],int id[],int n)
{
int i,j;
for(i=1; i<=n; i++)
{
if(id[i]==0)
{
id[i]=-1;
temp[++k]=i;
for(j=1; j<=n; j++)
{
if(a[i][j]==1 && id[j]!=-1)
id[j]--;
}
i=0;
}
}
}
void main()
{
int a[10][10],id[10],n,i,j;
printf("\nEnter the n value:");
scanf("%d",&n);
for(i=1; i<=n; i++)
21
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
id[i]=0;
printf("\nEnter the graph data:\n");
for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
{
scanf("%d",&a[i][j]);
if(a[i][j]==1)
id[j]++;
}
sort(a,id,n);
if(k!=n)
printf("\nTopological ordering not possible");
else
{
printf("\nTopological ordering is:");
for(i=1; i<=k; i++)
printf("%d ",temp[i]);
}
getch();
}

OUTPUT:

Enter the n value:6

Enter the graph data:
001100
000110
000101
000001
000001
000000

Topological ordering is: 1 2 3 4 5 6

****************************************
Enter the n value:4
Enter the graph data:
1432
5421
5342
4123

Topological ordering not possible

22
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)

PROGRAM 6:

Design and implement C/C++ Program to solve 0/1 Knapsack problem using Dynamic
Programming method.

Aim: To implement 0/1 Knapsack problem using Dynamic programming

Definition: using Dynamic programming

It gives us a way to design custom algorithms which systematically search all possibilities (thus guaranteeing correctness)
while storing results to avoid recomputing (thus providing efficiency).
We are given a set of n items from which we are to select some number of items to be carried in a knapsack(BAG). Each item
has both a weight and a profit. The objective is to choose the set of items that fits in the knapsack and maximizes the profit.
Given a knapsack with maximum capacity W, and a set S consisting of n items , Each item i has some weight wi and benefit
value bi (all wi , bi and W are integer values)
Problem: How to pack the knapsack to achieve maximum total value of packed items?

ALGORITHM

//(n items, W weight of sack) Input: n, wi,,, vi and W – all integers

//Output: V(n,W)
// Initialization of first column and first row elements
Repeat for i = 0 to n
set V(i,0) = 0
Repeat for j = 0 to W
Set V(0,j) = 0
//complete remaining entries row by row
Repeat for i = 1 to n
repeat for j = 1 to W
if ( wi <= j ) V(i,j)) = max{ V(i-1,j), V(i-1,j-wi) + vi }
if ( wi > j ) V(i,j) = V(i-1,j)
Print V(n,W)

PROGRAM

#include<stdio.h>
int w[10],p[10],n;
int max(int a,int b)
{
return a>b?a:b;
}
int knap(int i,int m)
{

23
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
if(i==n) return w[i]>m?0:p[i];
if(w[i]>m) return knap(i+1,m);
return max(knap(i+1,m),knap(i+1,m-w[i])+p[i]);
}
int main()
{
int m,i,max_profit;
printf("\nEnter the no. of objects:");
scanf("%d",&n);
printf("\nEnter the knapsack capacity:");
scanf("%d",&m);
printf("\nEnter profit followed by weight:\n");
for(i=1; i<=n; i++)
scanf("%d %d",&p[i],&w[i]);
max_profit=knap(1,m);
printf("\nMax profit=%d",max_profit);
return 0;
}

OUTPUT:

Enter the no. of objects:4

Enter the knapsack capacity:5

Enter profit followed by weight:

12 3
43 5
45 2
55 3

Max profit=100

24
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)

PROGRAM 7:
Design and implement C/C++ Program to solve discrete Knapsack and continuous Knapsack
problems using greedy approximation method.

This program first calculates the profit-to-weight ratio for each item, then sorts the items based on this ratio in non-increasing order. It then
fills the knapsack greedily by selecting items with the highest ratio until the knapsack is full. If there's space left in the knapsack after
selecting whole items, it adds fractional parts of the next item. Finally, it prints the optimal solution and the solution vector.

Here's a simplified version of the C program to solve discrete Knapsack and continuous Knapsack problems using the greedy
approximation method:

#include <stdio.h>
#define MAX 50
int p[MAX], w[MAX], x[MAX];
double maxprofit;
int n, m, i;
void greedyKnapsack(int n, int w[], int p[], int m)
{
double ratio[MAX];

// Calculate the ratio of profit to weight for each item

for (i = 0; i < n; i++)
{
ratio[i] = (double)p[i] / w[i];
}
// Sort items based on the ratio in non-increasing order
for (i = 0; i < n - 1; i++)
{
for (int j = i + 1; j < n; j++)
{
if (ratio[i] < ratio[j])
{
double temp = ratio[i];
ratio[i] = ratio[j];
ratio[j] = temp;

int temp2 = w[i];

w[i] = w[j];
w[j] = temp2;

temp2 = p[i];
p[i] = p[j];
25
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
p[j] = temp2;
}
}
}
int currentWeight = 0;
maxprofit = 0.0;
// Fill the knapsack with items
for (i = 0; i < n; i++)
{
if (currentWeight + w[i] <= m)
{
x[i] = 1; // Item i is selected
currentWeight += w[i];
maxprofit += p[i];
}
else
{
// Fractional part of item i is selected
x[i] = (m - currentWeight) / (double)w[i];
maxprofit += x[i] * p[i];
break;
}
}
printf("Optimal solution for greedy method: %.1f\n", maxprofit);
printf("Solution vector for greedy method: ");
for (i = 0; i < n; i++)
printf("%d\t", x[i]);
}
int main()
{
printf("Enter the number of objects: ");
scanf("%d", &n);
printf("Enter the objects' weights: ");
for (i = 0; i < n; i++)
scanf("%d", &w[i]);
printf("Enter the objects' profits: ");
for (i = 0; i < n; i++)
scanf("%d", &p[i]);
printf("Enter the maximum capacity: ");
scanf("%d", &m);
greedyKnapsack(n, w, p, m);
return 0;
26
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
}

OUTPUT:

Enter the number of objects: 4

Enter the objects' weights: 56 78 98 78
Enter the objects' profits: 23 45 76 78
Enter the maximum capacity: 100
Optimal solution for greedy method: 78.0
Solution vector for greedy method: 1 0 0 0

27
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)

PROGRAM 8:

Design and implement C/C++ Program to find a subset of a given set S = {s1 , s2,…..,sn} of n
positive integers whose sum is equal to a given positive integer d.
AIM: An instance of the Subset Sum problem is a pair (S, t), where S = {x1, x2, ..., xn} is a set of positive integers and t(the
target) is a positive integer. The decision problem asks for a subset of S whose sum is as large as possible, but not larger than
t.
Algorithm: SumOfSub (s, k, r)
//Values of x[ j ], 1 <= j < k, have been determined
//Node creation at level k taking place: also call for creation at level K+1 if possible
// s = sum of 1 to k-1 elements and r is sum of k to n elements
//generating left child that means including k in solution
Set x[k] = 1
If (s + s[k] = d) then subset found, print solution
If (s + s[k] + s[k+1] <=d)
then SumOfSum (s + s[k], k+1, r – s[k])
//Generate right child i.e. element k absent
If (s + r - s[k] >=d) AND (s + s[k+1] )<=d
THEN { x[k]=0;
SumOfSub(s, k+1, r – s[k])

PROGRAM

#include<stdio.h>
#define MAX 10
int s[MAX],x[MAX],d;
void sumofsub(int p,int k,int r)
{
int i;
x[k]=1;
if((p+s[k])==d)
{
for(i=1; i<=k; i++)
if(x[i]==1)
printf("%d ",s[i]);
printf("\n");
}
else if(p+s[k]+s[k+1]<=d)
sumofsub(p+s[k],k+1,r
-s[k]);
if((p+r

28
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
-s[k]>=d) && (p+s[k+1]<=d))
{
x[k]=0;
sumofsub(p,k+1,r
-s[k]);
}
}
int main()
{
int i,n,sum=0;
printf("\nEnter the n value:");
scanf("%d",&n);
printf("\nEnter the set in increasing order:");
for(i=1; i<=n; i++)
scanf("%d",&s[i]);
printf("\nEnter the max subset value:");
scanf("%d",&d);
for(i=1; i<=n; i++)
sum=sum+s[i];
if(sum<d || s[1]>d)
printf("\nNo subset possible");
else
sumofsub(0,1,sum);
return 0;
}

OUTPUT:

Enter the n value:9

Enter the set in increasing order:1 2 3 4 5 6 7 8 9

Enter the max subset value:9

126
135
18
234
27
36
45
9
29
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
PROGRAM 9

Design and implement C/C++ Program to sort a given set of n integer elements using Selection Sort method and compute its time
complexity. Run the program for varied values of n> 5000 and record the time taken to sort. Plot a graph of the time taken versus
n. The elements can be read from a file or can be generated using the random number generator.

Aim: Sort a given set of elements using Selection sort and determine the time required to sort elements. Repeat the experiment
for different values of n, the number of elements in the list to be sorted and plot a graph of the time taken versus n.

Definition: selection sort is a sorting routine that scans a list of items repeatedly and, on each pass, selects the item with the
lowest value and places it in its final position. It is based on brute force approach. Sequential search is a Θ(n 2) algorithm on
all inputs.

Algorithm:
SelectionSort(A[0…n-1])
//sort a given array by select5ion sort
//input:A[0…n-1]of orderable elements
Output:Array a[0…n-1] Sorted in ascending order
for i<- 0 to n-2 do
min<-i
for j<-i+1 to n-1 do
if A[j]<A[min] min<-j
swap A[i] and A[min]

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

// Function to perform selection sort on an array

void selectionSort(int arr[], int n)
{
int i, j, min_idx;
for (i = 0; i < n-1; i++)
{
min_idx = i; // Assume the current element is the minimum
for (j = i+1; j < n; j++)
{
if (arr[j] < arr[min_idx])
{
min_idx = j; // Update min_idx if a smaller element is found
}
}
// Swap the found minimum element with the current element
30
DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
int temp = arr[min_idx];
arr[min_idx] = arr[i];
arr[i] = temp;
}
}

// Function to generate an array of random numbers

void generateRandomNumbers(int arr[], int n)
{
for (int i = 0; i < n; i++)
{
arr[i] = rand() % 10000; // Generate random numbers between 0 and 9999
}
}

int main()
{
int n;
printf("Enter number of elements: ");
scanf("%d", &n); // Read the number of elements from the user

if (n <= 5000)
{
printf("Please enter a value greater than 5000\n");
return 1; // Exit if the number of elements is not greater than 5000
}

// Allocate memory for the array

int *arr = (int *)malloc(n * sizeof(int));
if (arr == NULL)
{
printf("Memory allocation failed\n");
return 1; // Exit if memory allocation fails
}

// Generate random numbers and store them in the array

generateRandomNumbers(arr, n);

// Measure the time taken to sort the array

31
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
clock_t start = clock();
selectionSort(arr, n);
clock_t end = clock();

// Calculate and print the time taken to sort the array

double time_taken = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("Time taken to sort %d elements: %f seconds\n", n, time_taken);

// Free the allocated memory

free(arr);
return 0;
}

OUTPUT:
Enter number of elements: 6000
Time taken to sort 6000 elements: 0.031000 seconds

********************************************************************

Enter number of elements: 7000

Time taken to sort 7000 elements: 0.034000 seconds

********************************************************************

Enter number of elements: 8000

Time taken to sort 8000 elements: 0.047000 seconds

********************************************************************

Enter number of elements: 9000

Time taken to sort 9000 elements: 0.052000 seconds

********************************************************************

Enter number of elements: 10000

Time taken to sort 10000 elements: 0.077000 seconds

PROGRAM 10
32
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)

Design and implement C/C++ Program to sort a given set of n integer elements using Quick
Sort method and compute its time complexity. Run the program for varied values of n> 5000
and record the time taken to sort. Plot a graph of the time taken versus n. The elements can
be read from a file or can be generated using the random number generator.

Aim:
The aim of this program is to sort ‘n’ randomly generated elements using Quick sort and Plotting the graph of the time
taken to sort n elements versus n.

Definition: Quick sort is based on the Divide and conquer approach. Quick sort divides array according to their value.
Partition is the situation where all the elements before some position s are smaller than or equal to A[s] and all the elements
after position s are greater than or equal to A[s].
Efficiency: Cbest(n) Є Θ(nlog2n),Cworst(n) ЄΘ(n2),Cavg(n)Є1.38nlog2n

Algorithm: Quick sort (A[l….r])

// Sorts a sub array by quick sort
//Input : A sub array A[l..r] of A[0..n-1] ,defined by its left and right indices l
//and r
// Output : The sub array A[l..r] sorted in non decreasing order
if l < r
s = Partition (A[l..r]) //s is a split position
Quick sort (A[l …s-1])
Quick sort (A[s+1…r])

ALGORITHM Partition (A[l…r])

//Partition a sub array by using its first element as a pivot
// Input : A sub array A[l…r] of A[0…n-1] defined by its left and right indices l and // r (l < r)
// Output : A partition of A[l…r], with the split position returned as this function’s value
p=A[l]
i=l;
j=r+1;
repeat
delay(500);
repeat i= i+1 until A[i] >= p
repeat j=j-1 until A[J] <= p
Swap (A[i],A[j])
until I >=j
Swap (A[i],A[j]) // Undo last Swap when i>= j
Swap (A[l],A[j])
Return j

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

33
DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
// Function to swap two elements
void swap(int* a, int* b)
{
int t = *a;
*a = *b;
*b = t;
}

// Partition function for Quick Sort

int partition(int arr[], int low, int high)
{
int pivot = arr[high]; // Pivot element
int i = (low - 1); // Index of smaller element

for (int j = low; j <= high - 1; j++)

{
if (arr[j] < pivot)
{
i++; // Increment index of smaller element
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
return (i + 1);
}

// Quick Sort function

void quickSort(int arr[], int low, int high)
{
if (low < high)
{
int pi = partition(arr, low, high);

// Recursively sort elements before and after partition

quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}

34
DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
// Function to generate random numbers
void generateRandomNumbers(int arr[], int n)
{
for (int i = 0; i < n; i++)
{
arr[i] = rand() % 100000; // Generate random numbers between 0 and 99999
}
}

int main()
{
int n;
printf("Enter number of elements: ");
scanf("%d", &n); // Read the number of elements from the user

if (n <= 5000)
{
printf("Please enter a value greater than 5000\n");
return 1; // Exit if the number of elements is not greater than 5000
}

// Allocate memory for the array

int *arr = (int *)malloc(n * sizeof(int));
if (arr == NULL)
{
printf("Memory allocation failed\n");
return 1; // Exit if memory allocation fails
}

// Generate random numbers and store them in the array

generateRandomNumbers(arr, n);

// Measure the time taken to sort the array

clock_t start = clock();
quickSort(arr, 0, n - 1);
clock_t end = clock();

// Calculate and print the time taken to sort the array

double time_taken = ((double)(end - start)) / CLOCKS_PER_SEC;
35
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
printf("Time taken to sort %d elements: %f seconds\n", n, time_taken);

// Free the allocated memory

free(arr);
return 0;
}

OUTPUT:

Enter number of elements: 10000

Time taken to sort 10000 elements: 0.0000 seconds

********************************************************************

Enter number of elements: 20000

Time taken to sort 20000 elements: 0.015000 seconds

********************************************************************
Enter number of elements: 30000
Time taken to sort 30000 elements: 0.011000 seconds

********************************************************************

Enter number of elements: 35000

Time taken to sort 35000 elements: 0.003000 seconds

********************************************************************

Enter number of elements: 50000

Time taken to sort 50000 elements: 0.015000 seconds

36
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
PROGRAM 11

Design and implement C/C++ Program to sort a given set of n integer elements using Merge
Sort method and compute its time complexity. Run the program for varied values of n> 5000,
and record the time taken to sort. Plot a graph of the time taken versus n. The elements can
be read from a file or can be generated using the random number generator.

Aim:
The aim of this program is to sort ‘n’ randomly generated elements using Merge sort and Plotting the graph of the time
taken to sort n elements versus n.
Definition: Merge sort is a sort algorithm based on divide and conquer technique. It divides the array element based on the
position in the array. The concept is that we first break the list into two smaller lists of roughly the same size, and then use
merge sort recursively on the subproblems, until they cannot subdivide anymore. Then, we can merge by stepping through the
lists in linear time. Its time efficiency is Θ(n log n).
Algorithm: Merge sort (A[0…n-1]
// Sorts array A[0..n-1] by Recursive merge sort
// Input : An array A[0..n-1] elements
// Output : Array A[0..n-1] sorted in non decreasing order
If n > 1
Copy A[0…(n/2)-1] to B[0…(n/2)-1]
Copy A[0…(n/2)-1] to C[0…(n/2)-1]
Mergesort (B[0…(n/2)-1])
Mergesort (C[0…(n/2)-1])
Merge(B,C,A)

ALGORITHM Merge (B[0…p-1], C[0…q-1],A[0….p+q-1])

// merges two sorted arrays into one sorted array
// Input : Arrays B[0..p-1] and C[0…q-1] both sorted
// Output : Sorted array A[0…. p+q-1] of the elements of B and C
I = 0;
J = 0;
K= 0;
While I < p and j < q do
If B[i] <= C[j]
A[k]= B[I]; I= I+1;
Else
A[k] = B[i]; I=i+1
K=k+1;
If I = = p
Copy C[ j..q-1] to A[k….p+q-1]
else
Copy B[I … p-1] to A[k …p+q-1

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

// Function to merge two sorted arrays

37
DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
void merge(int arr[], int left, int mid, int right)
{
int i, j, k;
int n1 = mid - left + 1;
int n2 = right - mid;

int *L = (int *)malloc(n1 * sizeof(int));

int *R = (int *)malloc(n2 * sizeof(int));

for (i = 0; i < n1; i++)

L[i] = arr[left + i];
for (j = 0; j < n2; j++)
R[j] = arr[mid + 1 + j];

i = 0;
j = 0;
k = left;

while (i < n1 && j < n2)

{
if (L[i] <= R[j])
{
arr[k] = L[i];
i++;
}
else
{
arr[k] = R[j];
j++;
}
k++;
}

while (i < n1)

{
arr[k] = L[i];
i++;
k++;
}
38
DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)

while (j < n2)

{
arr[k] = R[j];
j++;
k++;
}

free(L);
free(R);
}

// Function to implement Merge Sort

void mergeSort(int arr[], int left, int right)
{
if (left < right)
{
int mid = left + (right - left) / 2;

mergeSort(arr, left, mid);

mergeSort(arr, mid + 1, right);

merge(arr, left, mid, right);

}
}

// Function to generate random integers

void generateRandomArray(int arr[], int n)
{
for (int i = 0; i < n; i++)
arr[i] = rand() % 100000; // Generate random integers between 0 and 99999
}

int main()
{
int n;
printf("Enter the number of elements: ");
scanf("%d", &n);

39
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
if (n <= 5000)
{
printf("Please enter a value greater than 5000\n");
return 1; // Exit if the number of elements is not greater than 5000
}

int *arr = (int *)malloc(n * sizeof(int));

if (arr == NULL)
{
printf("Memory allocation failed\n");
return 1; // Exit if memory allocation fails
}

generateRandomArray(arr, n);

// Repeat the sorting process multiple times to increase duration for timing
clock_t start = clock();
for (int i = 0; i < 1000; i++)
{
mergeSort(arr, 0, n - 1);
}
clock_t end = clock();

// Calculate the time taken for one iteration

double time_taken = ((double)(end - start)) / CLOCKS_PER_SEC / 1000.0;

printf("Time taken to sort %d elements: %f seconds\n", n, time_taken);

free(arr);
return 0;
}

OUTPUT:

Enter number of elements: 6000

Time taken to sort 6000 elements: 0.000709 seconds

********************************************************************
40
DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
Enter number of elements: 7000
Time taken to sort 7000 elements: 0.000752 seconds

********************************************************************

Enter number of elements: 8000

Time taken to sort 8000 elements: 0.000916 seconds

********************************************************************

Enter number of elements: 9000

Time taken to sort 9000 elements: 0.001493 seconds

********************************************************************

Enter number of elements: 10000

Time taken to sort 10000 elements: 0.001589 seconds

********************************************************************

Enter number of elements: 11000

Time taken to sort 11000 elements: 0.002562 seconds

********************************************************************

Enter number of elements: 12000

Time taken to sort 12000 elements: 0.001944 seconds

********************************************************************

Enter number of elements: 13000

Time taken to sort 13000 elements: 0.002961 seconds

********************************************************************
Enter number of elements: 15000
Time taken to sort 15000 elements: 0.003563 seconds

41
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
PROGRAM 12

Design and implement C/C++ Program for N Queen’s problem using Backtracking.

Aim: To implement N Queens Problem using Back Tracking

Definition:
The object is to place queens on a chess board in such as way as no queen can capture another one in a single move
Recall that a queen can move horz, vert, or diagonally an infinite distance.
This implies that no two queens can be on the same row, col, or diagonal We usually want to know how many different
placements there are Using Backtracking Techniques

Algorithm:
/* outputs all possible acceptable positions of n queens on n x n chessboard */
// Initialize x [ ] to zero
// Set k = 1 start with first queen
Repeat for i = 1 to n // try all columns one by one for kth queen
if Place (k, i) true then
{
x(k) = i // place kth queen in column i
if (k=n) all queens placed and hence print output (x[ ])
else NQueens(K+1,n) //try for next queen
}
Place (k,i)
/* finds if kth queen in kth row can be placed in column i or not; returns true if queen can be placed */
// x[1,2, . . . k-1] have been defined
//queens at (p, q) & (r, s) attack if |p-r| = |q-s|
Repeat for j = 1 to (k-1)
if any earlier jth queen is in ith column ( x[j]= i)
or in same diagonal ( abs(x[ j] - i) = abs( j - k) )
then kth queen cannot be placed (return false)
return true (as all positions checked and no objection)

PROGRAM
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

// Function to print the solution

void printSolution(int **board, int N)
{
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
printf("%s ", board[i][j] ? "Q" : "#");
}
printf("\n");
42
DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
}
}

// Function to check if a queen can be placed on board[row][col]

bool isSafe(int **board, int N, int row, int col)
{
int i, j;

// Check this row on left side

for (i = 0; i < col; i++)
{
if (board[row][i])
{
return false;
}
}

// Check upper diagonal on left side

for (i = row, j = col; i >= 0 && j >= 0; i--, j--)
{
if (board[i][j])
{
return false;
}
}

// Check lower diagonal on left side

for (i = row, j = col; j >= 0 && i < N; i++, j--)
{
if (board[i][j])
{
return false;
}
}

return true;
}

// A recursive utility function to solve N Queen problem

43
DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
bool solveNQUtil(int **board, int N, int col)
{
// If all queens are placed, then return true
if (col >= N)
{
return true;
}

// Consider this column and try placing this queen in all rows one by one
for (int i = 0; i < N; i++)
{
if (isSafe(board, N, i, col))
{
// Place this queen in board[i][col]
board[i][col] = 1;

// Recur to place rest of the queens

if (solveNQUtil(board, N, col + 1))
{
return true;
}

// If placing queen in board[i][col] doesn't lead to a solution,

// then remove queen from board[i][col]
board[i][col] = 0; // BACKTRACK
}
}

// If the queen cannot be placed in any row in this column col, then return false
return false;
}

bool solveNQ(int N)
{
int **board = (int **)malloc(N * sizeof(int *));
for (int i = 0; i < N; i++)
{
board[i] = (int *)malloc(N * sizeof(int));
for (int j = 0; j < N; j++)
44
 DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)
{
board[i][j] = 0;
}
}

if (!solveNQUtil(board, N, 0))
{
printf("Solution does not exist\n");
for (int i = 0; i < N; i++)
{
free(board[i]);
}
free(board);
return false;
}

printSolution(board, N);

for (int i = 0; i < N; i++)

{
free(board[i]);
}
free(board);
return true;
}

int main()
{
int N;
printf("Enter the number of queens: ");
scanf("%d", &N);
solveNQ(N);
return 0;
}

OUTPUT:
45
DESIGN AND ANALYSIS OF ALGORITHMS LABORATORY(BCSL404)

************************OUTPUT-1************************

Enter the number of queens: 4

##Q#
Q###
###Q
#Q##

************************OUTPUT-2************************

Enter the number of queens: 3

Solution does not exist

46