(UPDATED) DAA_LAB_MANUAL 2023

RNS INSTITUTE OF TECHNOLOGY
(AICTE Approved, VTU Affiliated and NAAC ‘A+ Grade’ Accredited)

(UG programs – CSE, ECE, ISE, EIE and EEE have been Accredited by NBA up to 30/6/2025)
Channasandra, Dr. Vishnuvardhan Road, Bengaluru - 560 098
DEPARTMENT OF COMPUTER SCIENCE &ENGINEERING (Data Science)
DESIGN & ANALYSIS OF

ALGORITHMS LABORATORY
MANUAL
For Fourth Semester B.E-2021 Batch

[VTU/CBCS, 2021 syllabus]
Subject Code – 21CS42
NAME : .......................................................................................................................................................................................................................................................................................................................................................................................................................................
USN :.....................................................................................................................................................................................................................................................................................................................................................................................................................................................
SECTION : ................................................................................................................................................................... BATCH : ...........................................................................................................................................................................................

VISION AND MISSION OF INSTITUTION
Vision
Building RNSIT into a World Class Institution
Mission
To impart high quality education in Engineering, Technology and Management with a
Difference, Enabling Students to Excel in their Career by
1. Attracting quality Students and preparing them with a strong foundation in fundamentals so as to
achieve distinctions in various walks of life leading to outstanding contributions
2. Imparting value based, need based, choice based and skill based professional education to the
aspiring youth and carving them into disciplined, World class Professionals with social
responsibility
3. Promoting excellence in Teaching, Research and Consultancy that galvanizes academic
consciousness among Faculty and Students
4. Exposing Students to emerging frontiers of knowledge in various domains and make them suitable
for Industry, Entrepreneurship, Higher studies, and Research & Development
5. Providing freedom of action and choice for all the Stake holders with better visibility
VISION AND MISSION OF CSE DEPARTMENT

Vision
Empowering students to solve complex real-time computing problems involving high
volume multi-dimensional data
Mission
The Department of Computer Science and Engineering (Data Science) will make every effort
to promote an intellectual and an ethical environment in which the strengths and skills of
Computer Professionals will flourish by
1. Provide quality undergraduate education in both theoretical and applied computer science to
solve real world problems
2. Conduct research to develop algorithms that solve complex problems involving multi-
dimensional high volume data through intelligent inferencing.
3. Develop good linkages with industry and research organizations within India and abroad to
expose students to global problems and find optimal solutions.
4. Creating confident Graduates who can contribute to the nation through high levels
of commitment following ethical practices and with integrity
PREFACE
We have developed this comprehensive laboratory manual on Design & Analysis of Algorithms
Laboratory (21CS42) with the primary objectives: To make the students comfortable with Java
Programming Language using the eclipse software.
This material is comprised of solutions for 12 lab experiments, additional programs to show the
different ways to solve the same problem and encourage students to come up with their own creative
ways to solve them and to gain better knowledge on real world problems and includes Viva questions.
Our profound and sincere efforts will be fruitful only when students acquire the extensive knowledge
by reading this manual and apply the concepts learnt apart from the requirements specified in Design
& Analysis of Algorithms Laboratory as prescribed by VTU, Belagavi.
Department of CSE(DS)
ACKNOWLEDGMENT
A material of this scope would not have been possible without the contribution of many people. We express
our sincere gratitude to Dr. Satish R Shetty, Chairman, RNS Group of Companies for his magnanimous
support in all our endeavors.
We are grateful to Dr. Ramesh Babu H S, Principal, RNSIT and Dr. Srinivas A, HOD, CSE(DS) for extending
their constant encouragement and support.
Our heartfelt thanks to Dr. Sreevidya R C for unparalleled contribution throughout the preparation of this
comprehensive manual. We also acknowledge our colleagues for their timely suggestions and unconditional
support.
Department of CSE(DS)
Department of CSE, RNSIT

Design & Analysis of Algorithms Laboratory- 21CS42
INTERNAL EVALUATION SHEET
EVALUATION (MAX MARKS 20)

TEST REGULAR RECORD TOTAL MARKS
EVALUATION
A B C A+B+C
5 5 10 20
R1: REGULAR LAB EVALUATION WRITE UP RUBRIC (MAX MARKS 10)

Sl. Needs
No. Parameters Good Average
improvement
a. Understanding of Clear understanding of problem Problem statement is understood Problem statement is not
problem statement while designing and clearly but few mistakes while clearly understood while
(3 marks) implementing the program (3) designing and implementing designing the program (1)
program (2)
b. Writing program Program handles all possible Average condition is defined and Program does not handle
(4 marks) conditions (4) verified. (3) possible conditions (1)
c. Result and Meticulous documentation and Acceptable documentation shown Documentation does not
documentation all conditions are taken care (3) (2) take care all conditions
(3 marks) (1)
R2: REGULAR LAB EVALUATION VIVA RUBRIC (MAX MARKS 10)

Sl. Needs
Parameter Excellent Good Average
No. Improvement
a. Conceptual Answers 80% of the Answers 60% of the viva Answers 30% of the Unable to relate the
understanding viva questions asked questions asked (7) viva questions asked concepts (1)
(10 marks) (10) (4)
R3: REGULAR LAB PROGRAM EXECUTION RUBRIC (MAX MARKS 10)
Sl.
Parameters Excellent Good Needs Improvement
No.
a. Design, Program follows syntax and Program has few logical Syntax and semantics
implementation,and semantics of Java programming errors, moderately of Java programming is
demonstration language. Demonstrates the demonstrates all possible not clear (1)
(5 marks) complete knowledge of the concepts implemented in
program written (5) programs (3)
b. Result and All expected results are Moderately debugs the Expected results are not
documentation demonstrated successful, all program and Partial demonstrated properly,
(5 marks) errors are debugged with own documentation. unable to debug the
practical knowledge and clear (3) errors and no proper
documentation according to the documentation (1)
guidelines (5)
R4: RECORD EVALUATION RUBRIC (MAX MARKS 20)

Sl. Needs
Parameter Excellent Good Average
No. Improvement
a. Documentation Meticulous record writing Write up contains Write up contains Program written
(10 marks) including program, comments program and expected only program (5) with few mistakes
and expected output as per the output, but comments (1)
guidelines mentioned (10) are not included (8)

A. TEST /LAB INTERNALS MARKS (MAX MARKS 5)
Write up Execution Viva Sign Total Avg. Final
TEST # 7 35 8 40 40 5
TEST-1
TEST-2 5𝟎 5
B. REGULAR LAB EVALUATION (MAX MARKS 5)
Write
Date of Exen. Viva Total Teacher
Program # Lab programs up
Execution (10) (10) 30 Signature
(10)
10
11
12
Avg.
Total 30 𝟑𝟎 5
Marks

FINAL MARKS OBTAINED
A: TEST (5) TOTAL Signature of lab in charge:

(A+B+C)
B: REGULAR EVALUATION (5)
C: RECORD (10) 2𝟎

Design & Analysis of Algorithms Laboratory (21CS42)
TABLE OF CONTENTS
SL. PAGE
NO. CONTENTS
NO.
LABORATORY PROGRAMS
PART A
1 Selection Sort
1.1 Program
1.2 Output
2 Quick Sort
2.1 Program
2.2 Output
3 Merge Sort
3.1 Program
3.2 Output
4 Greedy Kanpsack
4.1 Program
4.2 Output
5 Single Source Shortest Path Problem (Dijkstra’s)

5.1 Program
5.2 Output
6 Minimum Cost Spanning Tree (Kruskal’s)

6.1 Program
6.2 Output
7 Minimum Cost Spanning Tree (Prim’s)

7.1 Program
7.2 Output
8 All Pair Shortest Path Problem (Floyd’s)

8.1 Program
8.2 Output
9 Travelling Salesperson Problem

9.1 Program
9.2 Output
10 Dynamic Knapsack
10.1 Program
10.2 Output
11 Sum of Subset
11.1 Program
11.2 Output
viii
12 Hamilton Cycle
12.1 Program
12.2 Output
ix
SYALLABUS
SEMESTER – IV
DESIGN & ANALYSIS OF ALGORITHMS LABORATORY
(Effective from the academic year 2021-2022)
Course Code – 21CS42 CIE Marks - 50
Number of Contact Hours/Week -3:0:2:0 SEE Marks - 50
Total Number of Lab Contact Hours - 20 Exam Hours - 03
Course Learning Objectives:
This course will enable students to:
1. Explain the methods of analyzing the algorithms and to analyze performance of algorithms.
State algorithm’s efficiencies using asymptotic notations.
3. Solve problems using algorithm design methods such as the brute force method, greedy
method, divide and conquer, decrease, and conquer, transform, and conquer, dynamic
programming, backtracking and branch and bound.
4. Choose the appropriate data structure and algorithm design method for a specified
application.
5. Introduce P and NP classes.
Programs List:
1. 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 non graph sheet. The elements can be read from
a file or can be generated using the random number generator. Demonstrate using Java
how the divide and-conquer method works along with its time complexity analysis: worst
case, average case, and best case.
2. 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
how the divide and conquer method works along with its time complexity analysis: worst
3. 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
4. Implement in Java, the 0/1 Knapsack problem using Greedy method.
5. From a given vertex in a weighted connected graph, find shortest paths to other vertices
using Dijkstra's algorithm. Write the program in Java.
x
6. Find Minimum Cost Spanning Tree of a given connected undirected graph using Kruskal's
algorithm. Use Union-Find algorithms in your program.
7. Find Minimum Cost Spanning Tree of a given connected undirected graph using Prim's
algorithm.
8. Implement in Java, the 0/1 Knapsack problem using Dynamic Programming method.
9. Write Java programs to implement All-Pairs Shortest Paths problem using Floyd's
algorithm.
10. Write Java programs to implement Travelling Salesperson problem using Dynamic
programming.
11. Design and implement in Java to find a subset of a given set S = {Sl, S2,.....,Sn} of n
positive integers whose SUM is equal to a given positive integer d. For example, if S ={1,
2, 5, 6, 8} and d= 9, there are two solutions {1,2,6}and {1,8}. Display a suitable message,
if the given problem instance doesn't have a solution.
12. Design and implement in Java to find all Hamiltonian Cycles in a connected undirected
Graph G of n vertices using backtracking principle.
Laboratory Outcomes: The student should be able to:

• Apply various algorithmic techniques.
• Analyzing the algorithms for time efficiency.
Practical Sessions need to be assessed by appropriate rubrics and viva-voce method.

This will contribute to 20 marks.
Note: Minimum of 80% of the laboratory components must be covered.
• Rubrics for each Experiment taken average for all Lab programs – 15 Marks.
• Viva-Voce– 5 Marks (more emphasized on demonstration topics)
xi
DESIGN & ANALYSIS OF LABORATORY (21CS42)
SELECTION SORT
1. Sort a given set of n integer elements using ALGORITHMS selection s o r t method and
compute its timecomplexity. 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 on graph sheet. The elements can
be read from a fileor can be generated using the random number generator. Demonstrate
using Java how thedivide-and-conquer method works along with its time complexity
analysis: worst case, averagecase and best case.
package first_demo;
import java.util.Random;
import java.util.Scanner;
public class sel_sort {

static int max = 10000;
static void selectionSort(int[] a,int ){

//int n;
for (int i=0;i<n-1;i++)
{
int temp;
for (int j=i+1;j<n;j++){
if (a[i] > a[j]){
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
public static void main(String[] args)

{
int[] a;
int i;
System.out.println("Enter the
array size");
Scanner sc = new
Scanner(System.in);
int n =
sc.nextInt();
a = new int[max];
Random generator = new
Page | 12
Random();
for (i = 0; i < n; i++)
a[i] =
generator.nextInt(200);
System.out.println("Array
before sorting");
for (i = 0; i < n; i++)
System.out.println(a[i]
+ " ");
long startTime =
System.nanoTime();
selectionSort(a,n);
long stopTime =
System.nanoTime();
long elapseTime = (stopTime

- startTime);
System.out.println("Time
taken to sort array is:" + elapseTime +
"nanoseconds");
System.out.println("Sorted
array is");
for (i = 0; i < n; i++)
System.out.println(a[i]);
}
Page | 13
QUICK SORT
2. 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 on graph sheet. The elements can be read from a
fileor can be generated using the random number generator. Demonstrate using Java how
thedivide-and-conquer method works along with its time complexity analysis: worst case,
averagecase and best case.
Quick sort is important sorting algorithm that is based on the divide-and conquers approach.
Quick sort divides them according to their value. Specifically, it rearranges elements of a given
array A[O .. n - 1] to achieve its partition, a situation where all the elements before some position
s are smaller than or equal to A[s] and all the elements after positions are greater than or equal
to A[s]:
Program
import java.util.Random;
import java.util.Scanner;
class QuickSort {
static int comparisons = 0;static int[] arr;
static void quickSort(int low, int high) {if (low < high) {
comparisons += 1;
int j = partition(low, high);quickSort(low, j

- 1); quickSort(j + 1, high);
}
}
static int partition(int low, int high) {int pivot = arr[low];

int i = low, j = high;while (i < j)
{
comparisons += 1;
while (i < high && arr[i] <= pivot) {comparisons += 2;
i = i + 1;
}
Page | 14
while (j > low && arr[j] >= pivot) {comparisons +=

2;
j = j - 1;
}
if (i < j) {
comparisons += 1;
interchange(i, j);
}
}
arr[low] = arr[j];arr[j] =
pivot; return j;
}
static void interchange(int i, int j) {int temp = arr[i];

arr[i] = arr[j];
arr[j] = temp;
}
public static void main(String[] args) {int n;

Scanner scanner = new Scanner(System.in);
System.out.println("Enter n value");
n = scanner.nextInt();arr = new
int[n];
System.out.println("Quick Sort"); System.out.println("1.
Best/Average Case");System.out.println("2. Worst Case");
int ch = scanner.nextInt();switch (ch) {

case 1:
Random random = new Random();for (int i
= 0; i < n; i++) {
arr[i] = random.nextInt();
}
break;
case 2:
for (int i = 0; i < n; i++) {
arr[i] = i + 1;
}
break;
}
long start = System.nanoTime();quickSort(0,

n - 1);
long end = System.nanoTime();
Page | 15
System.out.println("Sorted Array");for (int i = 0; i <

n; i++) {
System.out.println(arr[i]);
}
System.out.println("Time taken: " + (end - start));

System.out.println("Comparisons: " + comparisons);
}
}
Test Cases
Test No Input Parameters Expected Output Obtained Output
1 20,30,2,8,9,10 2,8,9,10,20,30 2,8,9,10,20,30
2 899,969,23,69,5 5,23,69,899,969 5,23,69,899,969
3 6,5,9,8,4,2 2,4,5,6,8,9 2,4,5,6,8,9
4 9,8,7,6,5,4,3 3,4,5,6,7,8,9 3,4,5,6,7,8,9
Page | 16
MERGE SORT
3. 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 on graph sheet. The elements can be read from
case, average case and best case.
Merge sort is a perfect example of a successful application of the divide-and conquer technique.
It sorts a given array A[O .. n - 1] by dividing it into two halves A[0 .. [n/2] -1] and A[n/2 .. n -
1], sorting each of them recursively, and then merging the two smaller sorted arrays into a single
sorted one.
Program
import java.util.Random; import

java.util.Scanner;
class MergeSort {
static int comparisons = 0;static int[] arr;
static void mergeSort(int low, int high) {if (low < high) {
comparisons += 1;
int mid = (low + high) / 2;

mergeSort(low, mid); mergeSort(mid +
1, high); merge(low, mid, high);
}
}
static void merge(int low, int mid, int high) {int n = high - low + 1;
int[] t_arr = new int[n];
int i = low, j = mid + 1, k = 0;
Page | 17
public static void main(String[] args) {int n;

System.out.println("Enter n value");
n = scanner.nextInt();arr = new
int[n];
int ch;
System.out.println("Merge Sort"); System.out.println("1.
Best Case"); System.out.println("2. Average Case");
System.out.println("3. Worst Case"); ch =
scanner.nextInt();
switch (ch) {case
1:
for (int i = 0; i < n; i++) {arr[i] = i + 1;
}
break;
case 2:
Random random = new Random();for (int i
= 0; i < n; i++) {
arr[i] = random.nextInt();
}
break;
case 3:
for (int i = 0; i < n; i++) {arr[i] = n - i;
}
// for (int i = 0; i < n; i++) {
// arr[i] = i + 1;
// }
// generateWorstCase(0, n - 1);break;
}
long start = System.nanoTime();mergeSort(0,

n - 1);
long end = System.nanoTime();
System.out.println("Sorted Array");
// Print the time taken to sort. System.out.println("Time Taken: " + (end -

start));
// Print the number of comparisons.
Page | 18
System.out.println("Comparisons: " + comparisons);

}
// static void generateWorstCase(int low, int high) {

// if (low < high) {
// int mid = (low + high) / 2;
// partition(low, high);
// generateWorstCase(low, mid);
// generateWorstCase(mid + 1, high);
// }
// }
// static void partition(int low, int high) {

// int n = high - low + 1;
// int k = 0;
// int t_arr[] = new int[n];
// for (int i = low; i <= high; i += 2) {

// // Read elements at odd positions w.r.t. low.
// t_arr[k] = arr[i];
// k++;
// }
// for (int i = low + 1; i <= high; i += 2) {

// // Read elements at even positions w.r.t. low.
// t_arr[k] = arr[i];
// k++;
// }
// for (int i = 0; i < n; i++) {

// // Copy elements from temporary array to theoriginal array.
// arr[low + i] = t_arr[i];
// }
// }
Page | 19
Test Cases
1 20,30,2,8,9,10 2,8,9,10,20,30 2,8,9,10,20,30
2 899,969,23,69,5 5,23,69,899,969 5,23,69,899,969
3 6,5,9,8,4,2 2,4,5,6,8,9 2,4,5,6,8,9
4 9,8,7,6,5,4,3 3,4,5,6,7,8,9 3,4,5,6,7,8,9
Page | 20
KNAPSACK PROBLEM
4. Implement in Java, the 0/1 Knapsack problem using Dynamic Programming method.
The knapsack problem is a problem in combinatorial optimization: Given a set of items, each
with a weight and a value, determine the number of each item to include in a collection so that
the total weight is less than or equal to a given limit and the total value is as large as possible.
Program
import java.util.Scanner;class
Knapsack {
private int[] weight, profit;private int
capacity, n;
Knapsack() {
System.out.println("Enter Number of Items");n =

scanner.nextInt();
weight = new int[n];profit =
new int[n];
System.out.println("Enter Weights of Items");for (int i = 0; i < n;

i++) {
weight[i] = scanner.nextInt();
}
System.out.println("Enter Profits of Items");for (int i = 0; i < n;

i++) {
profit[i] = scanner.nextInt();
}
System.out.println("Enter Capacity of Knapsack");capacity =

scanner.nextInt();
}
Page | 21
void fill() {
int[][] K = new int[n + 1][capacity + 1];
for (int i = 0; i <= n; i++) {

for (int j = 0; j <= capacity; j++) {if (i == 0 || j == 0) {
K[i][j] = 0;
} else if (j < weight[i - 1]) {K[i][j] = K[i -
1][j];
} else {
K[i][j] = Math.max(K[i - 1][j], profit[i
- 1] + K[i - 1][j - weight[i - 1]]);
}
}
}
System.out.println("Maximum Profit: " +
(K[n][capacity]));
System.out.print("Items Considered: ");int i = n, j =
capacity;
while (i > 0 && j > 0) {

if (K[i][j] != K[i - 1][j]) {
System.out.print(i + " ");
j -= weight[i - 1];
}
i -= 1;
}
System.out.println();
}
public static void main(String[] args) {Knapsack knapsack

= new Knapsack(); knapsack.fill();
}
}
Test Cases
Page | 22
Page | 23
Implement in Java, the 0/1 Knapsack problem using Greedy method.
Program
Knapsack {
private double[] weight, profit, ratio, solnVector;private double capacity;
Knapsack() {
System.out.println("Enter number of Items");int n =
scanner.nextInt();
weight = new double[n]; profit = new
double[n]; ratio = new double[n];
solnVector = new double[n];
System.out.println("Enter Weights of Items");for (int i = 0; i < n;

i++) {
weight[i] = scanner.nextDouble();
}
System.out.println("Enter Profits of Items");for (int i = 0; i < n;

i++) {
profit[i] = scanner.nextDouble();
}
System.out.println("Enter Capacity of Knapsack");capacity =

scanner.nextDouble();
}
int getNext() {
int index = -1;
double highest = 0;
Page | 24
for (int i = 0; i < ratio.length; i++) {if (ratio[i] > highest) {

highest = ratio[i];index = i;
}
}
return index;
}
void fill() {
double currentWeight = 0;double
currentProfit = 0;
for (int i = 0; i < ratio.length; i++) {ratio[i] = profit[i] /

weight[i];
}
System.out.print("Items Considered: ");while

(currentWeight < capacity) {
int item = getNext();
if (item == -1) {break;

}
System.out.print((item + 1) + " ");
if (currentWeight + weight[item] <= capacity) {currentWeight +=

weight[item]; currentProfit += profit[item]; solnVector[item] =
1;
ratio[item] = 0;
}
else
{
currentProfit += ratio[item] * (capacity - solnVector[item] =
currentWeight);
(capacity - currentWeight)break;
/ weight[item];
}
}
Page | 25
System.out.println(); System.out.println("Maximum Profit is: " +

currentProfit);
System.out.print("Solution Vector: ");
for (int i = 0; i < solnVector.length; i++) {
System.out.print(solnVector[i] + " ");
}
}
public static void main(String[] args) {Knapsack knapsack

= new Knapsack(); knapsack.fill();
}
}
Test Cases
Page | 26
DIJKSTRA'S ALGORITHM
7. From a given vertex in a weighted connected graph, find shortest paths to other vertices
using Dijkstra's algorithm. Write the program in Java.
Program
import java.util.Scanner;class Main {
public static void main(String[] args) { Scanner scanner = new

Scanner(System.in);
System.out.println("Enter Number of Vertices");int n =
scanner.nextInt();
int adj[][] = new int[n][n];
System.out.println("Enter Adjacency Matrix");for (int i = 0; i < n;

i++) {
for (int j = 0; j < n; j++) { adj[i][j] =
scanner.nextInt();
}
}
System.out.println("Enter Source vertex");int src =

scanner.nextInt();
int[] dist = dijkstra(adj, src);for (int i = 0; i < n;
i++) {
if ((src - 1) == i) {continue;
}
System.out.println("Shortest Distance from"+src+"to
"+(i+1)+"is"+dist[i]);
}
}
static int[] dijkstra(int adj[][], int src) {int n = adj.length;
Page | 27
int[] dist = new int[n];

boolean[] visited = new boolean[n];int min_dist,
unvis = -1;
for (int i = 0; i < n; i++) { dist[i] = adj[src -

1][i];visited[i] = false;
}
visited[src - 1] = true;
for (int i = 1; i < n; i++) { min_dist =

Integer.MAX_VALUE;for (int j = 0; j < n;
j++) {
if (!visited[j] && dist[j] < min_dist) {unvis = j;
min_dist = dist[j];
}
}
visited[unvis] = true;
for (int v = 0; v < n; v++) {

if (!visited[v] && dist[unvis] +adj[unvis][v] < dist[v])
{
dist[v] = dist[unvis] + adj[unvis][v];
}
}
}
return dist;
}
}
Test Cases
Page | 28
KRUSKAL'S ALGORITHM
8. Find Minimum Cost Spanning Tree of a given connected undirected graph using Kruskal's
algorithm. Use Union-Find algorithms in your program.
Program
import java.util.Arrays; import

java.util.Scanner;
class Edge {
int src; int dest;
int weight;
Edge(int src, int dest, int weight) {this.src = src;

this.dest = dest; this.weight =
weight;
}
}
class Main {
Scanner(System.in);
System.out.println("Enter number of Vertices");int n =
scanner.nextInt();
int adj[][] = new int[n][n]; System.out.println("Enter Adjacency

Matrix");for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) { adj[i][j] =
scanner.nextInt();
}
}
// Maximum Edges without any Loops can be ((n * (n - 1))/ 2).
Edge[] edges = new Edge[(n * (n - 1)) / 2];
int k = 0;
for (int i = 0; i < n; i++) {
Page | 29
for (int j = i + 1; j < n; j++) { edges[k] = new Edge(i, j,

adj[i][j]);k++;
}
}
sort(edges);
// Declare an array of size vertices to keep track ofrespective leaders of each

element.
int[] parent = new int[n];
// Assign each element of array of with value -1.Arrays.fill(parent, -1);
int minCost = 0; System.out.println("Edges:

");for (int i = 0; i < k; i++) {
// Find the super most of leader of source vertex.int lsrc = find(parent,
edges[i].src);
// Find the super most of leader of destination vertex.int ldest = find(parent,
edges[i].dest);
// If those two leaders are different then they belong toisolated groups.
if (lsrc != ldest) { System.out.println((edges[i].src + 1) + " <->
" + (edges[i].dest + 1));
minCost += edges[i].weight;
union(parent, lsrc, ldest);
}
}
System.out.println("Minimum Cost of Spanning Tree: "
+ minCost);
}
static void sort(Edge[] edges) {

// Sort Edges according to their weights using Bubble Sort.for (int i = 1; i <
edges.length; i++) {
for (int j = 0; j < edges.length - i; j++) {
if (edges[j].weight > edges[j + 1].weight) {Edge temp = edges[j];
edges[j] = edges[j + 1];
Page | 30
edges[j + 1] = temp;
}
}
}
}
static int find(int[] parent, int i) {if (parent[i] == -1) {

// Super Most Leader Element Found.return i;
}
// Find Above Leader in recurrsive manner.return find(parent,
parent[i]);
}
static void union(int[] parent, int lsrc, int ldest) {

// Make destination vertex leader of source vertex.parent[lsrc] = ldest;
}
}
Test Cases
Page | 31
PRIM’S ALGORITHM
9. Find Minimum Cost Spanning Tree of a given connected undirected graph using Prim's
algorithm.
Program

Scanner(System.in);

scanner.nextInt();
int[][] costMatrix = new int[n][n];boolean[] visited
= new boolean[n];
System.out.println("Enter Cost Adjacency Matrix");for (int i = 0; i < n;

i++)
for (int j = 0; j < n; j++) costMatrix[i][j] = scanner.nextInt();
for (int i = 0; i < n; i++)visited[i] =

false;
System.out.println("Enter Source Vertex");int srcVertex =

scanner.nextInt();
visited[srcVertex - 1] = true;
int source = 0, cost = 0, target = 0;

System.out.print("Edges: ");
for (int i = 1; i < n; i++) { int min =

Integer.MAX_VALUE;
for (int j = 0; j < n; j++) {if (visited[j]) {
for (int k = 0; k < n; k++) {
Page | 32
if (!visited[k] && min >

costMatrix[j][k]) {
min = costMatrix[j][k];source = j;
target = k;
}
}
}
}
visited[target] = true; System.out.print("(" + (source + 1) + "," +
(target + 1) + ")");
cost += min;
}
System.out.println("\nMinimum cost of Spanning Tree: " +cost);
}
}
Test Cases
Page | 33
FLOYD'S ALGORITHM
10. a. Write Java programs to implement All-Pairs Shortest Paths problem using Floyd's
algorithm.
Program

Scanner(System.in);

scanner.nextInt();
int[][][] D = new int[n + 1][n][n];
System.out.println("Enter Distance Matrix");for (int i = 0; i < n;

i++) {
for (int j = 0; j < n; j++) { D[0][i][j] =
scanner.nextInt();
}
}
for (int k = 1; k <= n; k++) { for (int i = 0; i < n;

i++) {
for (int j = 0; j < n; j++) {
D[k][i][j] = Math.min(D[k - 1][i][j], D[k
- 1][i][k - 1] + D[k - 1][k - 1][j]);
}
}
}
System.out.println("Shortest Distance Matrix");for (int i = 0; i < n;

i++) {
for (int j = 0; j < n; j++) { System.out.print(D[n][i][j] + " ");
}
}
Page | 34
}
}
Test Cases
Page | 35
TRAVELLING SALESPERSON PROBLEM
10. b. Write Java programs to implement Travelling Salesperson problem using Dynamic
programming.
Program
import java.util.ArrayList;import
java.util.Scanner;
class Main {
static int[][] graph;static int n,
src;
public static void main(String args[]) { Scanner scanner = new

Scanner(System.in);
System.out.println("Enter number of cities");n = scanner.nextInt();
graph = new int[n][n];
System.out.println("Enter Adjacency Matrix");for (int i = 0; i < n;

i++) {
for (int j = 0; j < n; j++) { graph[i][j] =
scanner.nextInt();
}
}
System.out.println("Enter Source City");src =

scanner.nextInt();
ArrayList<Integer> set = new ArrayList<Integer>();for (int i = 0; i < n;

i++) {
if (i == (src - 1)) {continue;
}
set.add(i);
}
int[] path = new int[n + 1];
int cost = tsp(src - 1, set, path);
Page | 36
System.out.println("Total Cost: " + cost);
path[0] = src - 1;path[n] =

src - 1;
System.out.print("Path: ");
for (int i = n; i >= 0; i--) { System.out.print((path[i] + 1) + " ");
}
}
static int tsp(int v, ArrayList<Integer> set, int[] path)

{
if (set.isEmpty()) {
return graph[v][src - 1];
}
int size = set.size(); ArrayList<Integer> subSet;
int minCost = Integer.MAX_VALUE;for
(Integer i : set) {
subSet = new ArrayList<Integer>(set);
subSet.remove(i);
int[] tempPath = new int[n+1];
int cost = graph[v][i] + tsp(i, subSet,
tempPath);
if (cost < minCost) { minCost =

cost; tempPath[size] = i;
copyCentralArray(path, tempPath, size);
}
}
return minCost;
}
static void copyCentralArray(int[] dest, int[] src, intsize) {

for (int i = 1; i <= size; i++) {dest[i] = src[i];
}
}
}
Page | 37
Test Cases
Page | 38
SUBSET
11. Design and implement in Java to find a subset of a given set S = {Sl, S2,. ,Sn} of n positive
integers whose SUM is equal to a given positive integer d. For example, if S ={1, 2, 5, 6, 8} and
d= 9, there are two solutions {1,2,6}and {1,8}. Display a suitable message, if the given problem
instance doesn't have a solution.
Program

static int[] arr;static int
count;

Scanner(System.in);System.out.println("Enter n value");
int n = scanner.nextInt();arr = new
int[n];
System.out.println("Enter Elements of Set");for (int i = 0; i < n;

i++) {
arr[i] = scanner.nextInt();
}
System.out.println("Enter Total Sum value");int total =

scanner.nextInt();
subSet(total, n - 1, new boolean[n]);if (count == 0) {

System.out.println("No solution");
}
}
static void subSet(int total, int index, boolean[]solution) {

if (total == 0) { printSolution(solution);
} else if (total < 0 || index < 0) {return;
Page | 39
} else {
boolean[] tempSolution = solution.clone();
tempSolution[index] = false;
subSet(total, index - 1, tempSolution);
tempSolution[index] = true; subSet(total - arr[index],
index - 1,
tempSolution);
}
}
static void printSolution(boolean[] solution) {count += 1;

System.out.print("Solution: ");
for (int i = 0; i < solution.length; i++) {if (solution[i]) {
System.out.print(arr[i] + " ");
}
}
}
}
Test Cases
Page | 40
BACKTRACKING
12 Design and implement in Java to find all Hamiltonian Cycles in a connected undirected
Graph G of n vertices using backtracking principle.
Program
Hamiltonian {
static int[][] graph; static int[] soln;
static int n, count = 0;

Scanner(System.in);
System.out.println("Enter Number of Vertices");n = scanner.nextInt();
// Read Adjacency Matrix in Graph array(1 Indexed)graph = new int[n +

1][n + 1]; System.out.println("Enter Adjacency Matrix");
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) { graph[i][j] =
scanner.nextInt();
}
}
// Instatiate Solution array(1 Indexed), (Default Value is 0)soln = new int[n + 1];
System.out.println("Hamiltonian Cycle are");
// In a cycle source vertex doesn't matter

// Assign Starting Point to prevent repetitionssoln[1] = 1;
// Call Hamiltonian function to start backtracking from vertex 2
hamiltonian(2);
if (count == 0) {
System.out.println("No Hamiltonian Cycle");
Page | 41
}
}
static void hamiltonian(int k) {while (true) {
nextValue(k);
// No next vertex so returnif (soln[k] ==

0) {
return;
}
// if cycle is complete then print it else find next vertexif (k == n) {
printArray();
} else {
hamiltonian(k + 1);
}
}
}
static void nextValue(int k) {

// Finds next feasible valuewhile (true) {
soln[k] = (soln[k] + 1) % (n + 1);
// If no next vertex is left, then returnif (soln[k] == 0) {

return;
}
// If there exists an edge

if (graph[soln[k - 1]][soln[k]] != 0) {int j;
// Check if the vertex is not repeatedfor (j = 1; j < k; j++)
{
if (soln[j] == soln[k]) {break;
}
}
// If vertex is not repeatedif (j == k) {

// If the vertex is not the last vertex or it completes thecycle then return
if (k < n || (k == n && graph[soln[n]][soln[1]]
!= 0)) {
return;
}
}
}
}
}
static void printArray() {count += 1;

Page | 42
// Print Solution Array

for (int i = 1; i <= n; i++) { System.out.print(soln[i] + "
");
}
System.out.println(soln[1]);
}
}
Test Cases
Page | 43
Appendix-A
This section lists the Viva questions for each lab session:
SELECTION SORT
1. As the input size increases, the performance of selection sort decreases. (T/F)
2. What is the best case, worst case, average case time complexity for quick sort
algorithm?
3. Explain working of selection sort
QUICK SORT
1. Which sorting technique is also called partition exchange sort?

2. Which is the technique used by quick sort?
3. What is the best case, worst case, average case time complexity for quick sort
algorithm?
4. Explain divide and conquer technique.
5. Define in place sorting algorithm.
6. List different ways of selecting pivot element.
7. Is quick sort stable?
MERGE SORT
1. What is the best case, worst case, average case time complexity for merge sort
algorithm?
2. What is the output of merge sort after the 1st pass given the following sequence of
numbers?
25 57 48 37 12 92 86 33
3. What is the running time of merge sort?
4. What technique is used to sort elements in merge sort?
5. Is merge sort in place sorting algorithm?
6. Define stable sort algorithm. Is merge sort stable?
WARSHALL’S ALGORITHM
1. Define transitive closure.

2. Define topological sequence.
3. What is the time complexity of Warshall's algorithm?
KNAPSACK PROBLEM
1. Define knapsack problem.

2. Define the principle of optimality.
3. What is the optimal solution for knapsack problem?
4. What is the time complexity of knapsack problem?
5. Provide a use case where greedy knapsack cannot yield optimal solution.
Page | 44
SHORTEST PATHS ALGORITHM
1. What is the time complexity of Dijkstra’s algorithm?

2. Define cost matrix.
3. Define directed graph.
4. Define connected graph.
MINIMUM COST SPANNING TREE
1. What is the time complexity of Kruskal’s algorithm?

2. Define spanning tree.
3. Define minimum cost spanning tree.
GRAPH TRAVERSALS
1. Define graph, connected graph.

2. List the different graph traversals.
3. Explain DFS traversal.
4. Explain BFS traversal.
5. What are the time complexities of BFS and DFS algorithms?
6. What are the data structures used to implement DFS and BFS traversals?
SUM OF SUBSETS PROBLEM
1. Define Back-Tracking.
2. Explain Sum of subset problem.
3. What is the time complexity of sum of subset problem?
4. Let S= {1,2,3,4,5} and d= 6. Obtain the subsets whose sum leads to d
TRAVELLING SALESPERSON PROBLEM
1. Define Optimal Solution.

2. Explain Travelling Salesman’s Problem.
3. What is the time complexity of Travelling Salesman’s Problem?
4. For n- cities solutions are possible.
5. Deterministic algorithms exist for TSP(True/False)
6. Is TSP problem is NP-Hard or NP-Complete? Explain
MINIMUM COST SPANNING TREE
1. What is Minimum Cost spanning Tree.

2. Explain Prim’s algorithm.
3. What is the time complexity of Prim’s algorithm?
4. Explain the concept of Kruskal’s algorithm
5. Derive the time complexity for Kruskal’s algorithm.
Page | 45
Design & Analysis of algorithms (21CS42)
SINGLE SOURCE SHORTEST PATH
1. Define Single Source Shortest Path problem.

2. Explain positive and negative weight cycle along with some examples.
3. Estimate the time complexity of the Dijkstra’s algorithm.
ALL PAIRS SHORTEST PATH
1. Define All Pair Shortest Path Floyd’s algorithm (APSP)

2. What is the time complexity of Floyd’s algorithm?
3. Define Distance Matrix.
BACKTRACKING
1. Define n- Queens’s problem?

2. 3- Queen problem has a solution (T/ F)
3. DFS can be solved using backtracking (T/F).
4. What is promising and non-promising node?
5. Define Hamiltonian Cycle.
Page 46

(UPDATED) DAA_LAB_MANUAL 2023

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

(UPDATED) DAA_LAB_MANUAL 2023

Uploaded by

Copyright:

Available Formats

RNS INSTITUTE OF TECHNOLOGY

(AICTE Approved, VTU Affiliated and NAAC ‘A+ Grade’ Accredited)

DESIGN & ANALYSIS OF

For Fourth Semester B.E-2021 Batch

VISION AND MISSION OF CSE DEPARTMENT

Department of CSE, RNSIT

EVALUATION (MAX MARKS 20)

R1: REGULAR LAB EVALUATION WRITE UP RUBRIC (MAX MARKS 10)

R2: REGULAR LAB EVALUATION VIVA RUBRIC (MAX MARKS 10)

R3: REGULAR LAB PROGRAM EXECUTION RUBRIC (MAX MARKS 10)

R4: RECORD EVALUATION RUBRIC (MAX MARKS 20)

Department of CSE, RNSIT

B. REGULAR LAB EVALUATION (MAX MARKS 5)

Department of CSE, RNSIT

A: TEST (5) TOTAL Signature of lab in charge:

Department of CSE, RNSIT

5 Single Source Shortest Path Problem (Dijkstra’s)

6 Minimum Cost Spanning Tree (Kruskal’s)

7 Minimum Cost Spanning Tree (Prim’s)

8 All Pair Shortest Path Problem (Floyd’s)

9 Travelling Salesperson Problem

Course Code – 21CS42 CIE Marks - 50

Number of Contact Hours/Week -3:0:2:0 SEE Marks - 50

Total Number of Lab Contact Hours - 20 Exam Hours - 03

Course Learning Objectives:

This course will enable students to:

4. Implement in Java, the 0/1 Knapsack problem using Greedy method.

Laboratory Outcomes: The student should be able to:

Practical Sessions need to be assessed by appropriate rubrics and viva-voce method.

Note: Minimum of 80% of the laboratory components must be covered.

DESIGN & ANALYSIS OF LABORATORY (21CS42)

public class sel_sort {

static void selectionSort(int[] a,int ){

public static void main(String[] args)

long elapseTime = (stopTime

int j = partition(low, high);quickSort(low, j

static int partition(int low, int high) {int pivot = arr[low];

while (i < high && arr[i] <= pivot) {comparisons += 2;

while (j > low && arr[j] >= pivot) {comparisons +=

static void interchange(int i, int j) {int temp = arr[i];

public static void main(String[] args) {int n;

int ch = scanner.nextInt();switch (ch) {

long start = System.nanoTime();quickSort(0,

System.out.println("Sorted Array");for (int i = 0; i <

System.out.println("Time taken: " + (end - start));

1 20,30,2,8,9,10 2,8,9,10,20,30 2,8,9,10,20,30

2 899,969,23,69,5 5,23,69,899,969 5,23,69,899,969

3 6,5,9,8,4,2 2,4,5,6,8,9 2,4,5,6,8,9

4 9,8,7,6,5,4,3 3,4,5,6,7,8,9 3,4,5,6,7,8,9

import java.util.Random; import

int mid = (low + high) / 2;

public static void main(String[] args) {int n;

long start = System.nanoTime();mergeSort(0,

// Print the time taken to sort. System.out.println("Time Taken: " + (end -

System.out.println("Comparisons: " + comparisons);

// static void generateWorstCase(int low, int high) {

// static void partition(int low, int high) {

// for (int i = low; i <= high; i += 2) {

// for (int i = low + 1; i <= high; i += 2) {

// for (int i = 0; i < n; i++) {

1 20,30,2,8,9,10 2,8,9,10,20,30 2,8,9,10,20,30

2 899,969,23,69,5 5,23,69,899,969 5,23,69,899,969

3 6,5,9,8,4,2 2,4,5,6,8,9 2,4,5,6,8,9

4 9,8,7,6,5,4,3 3,4,5,6,7,8,9 3,4,5,6,7,8,9