ada lab progs

7/29/2019 Ada Lab Progs

1/80

Algorithm for Linear Search

Algorithm linear_search (A, i , n)//Purpose : search for an item in an array A[0..n-1] using linear search.

//Input: keythe element to be searched

// A[0..n-1]the list of elements where the searching takes place.// nnumber of elements in the list.//Output: Position is returned if search is successful otherwise,1 is returned

{

if i>nreturn -1

else

if A[i] keyreturn i

elselinear_search(A,++i,n)

}

Time complexity of Linear Search is (n)

Algorithm for Binary Search

Algorithm binary_search( A, low, high)

//Purpose : search for an item in an array A[0..n-1] using binary search.

//Input: keythe element to be searched// A[0..n-1]the list of elements where the searching takes place.

// nnumber of elements in the list.

//Output: Position is returned if search is successful otherwise,1 is returned{

low 0

high 1

if low > high

return -1

mid (low+high)/2

if a[mid] key

return mid

if a[mid] > key

binary_search(A,low,mid-1)

elsebinary_search(A,mid+1,high)

}

Time complexity of Binary Search in Best case is (1)Time complexity of Binary Search in Worst case is (log2 n)

Time complexity of Binary Search Average case is (n2)


2/80

/*1) Perform recursive binary search and linear search. Hence find the time required to

search an element.*/

#include

#include

#include#include //Inclusion of header files

int n,i=0;

int a[20]; //Global declaration

//Function to perform binary search

int bin_search(int a[],int key, int low,int high)

{int mid;

mid=(low+high)/2; //Finding the mid element

if(low>high) //Termination condition{

return -1;

}

if(a[mid]==key){

return mid; //If mid is the key return mid

}if(key


3/80

coutn;

cout


4/80

break;

default:cout


5/80

Algorithm for Heapsort

Algorithm heapsort (A , n)// Purpose: Sort the list in ascending order.

// Input: A[0..n-1]the list to be sorted

// nthe total number of elements.//Output:A[0..n-1]the sorted list{

call heapify(A , n)

for (i n to 2 by -1 do ){

t A[i]

A[i] A[i]

A[i] t

adjust(A,1,i-1)

}

}

//This algorithm readjust the elements in the array and to form a heap

Algorithm heapify (A, n)// Purpose: to create a max heap so that item at the root is the highest and given any node,

// the item at that node is greater than the item at left child and right child

// Input: A[0..n-1]the items to be inserted into the heap

// nthe number of items to be inserted into the heap.//Output:A[0..n-1]the contains the max heap

{for i n/2 to 1 by -1 do

{call adjust (A, i ,n)

}

}


6/80

Algorithm adjust( A, i ,n)

// Purpose: to create a max heap so that item at the root is the highest and given any node,

// the item at that node is greater than the item at left child and right child// Input: A[0..n-1]the items to be inserted into the heap

// nthe number of items to be inserted into the heap.

//Output:A[0..n-1]the contains the max heap{

j 2*i

item A[i]

while(j < = n) do

{

if (j < n ) and A[j] < A[j+1])

j j+1if item > = A[j]

then breakelse

{A[j] A[j/2]

j 2*j}

}

A[j/2] item

}

Time complexity of Heap Sort is (n log2 n)


7/80

/* 2) Sort a given set of elements using Heapsort method.*/

#include#include

#include

template //Creating a templatevoid heapify(T a[],int n)

{

int i,j,k;T item;

for(k=1;k0 && item>a[j]){ //while parent exist & item>parenta[i]=a[j]; //move parent down to childi=j; //make parent as child

j=(i-1)/2; //obtain new parent for child}

a[i]=item; //Insert item into childs position

}}

template

void adjust(X a[],int n){

int i=0,j;

X item;j=0;

item=a[j];

i=2*j+1;

while(i


8/80

}

a[j]=item; //Insert item to parent pos}

templatevoid heapsort(U a[],int n){

int i;

U temp;heapify(a,n); //calling the heapify functionfor(i=n-1;i>0;i--)

{

temp=a[0]; //swapping the root nodea[0]=a[i];

a[i]=temp;

adjust(a,i);}

}

templatevoid disp(D a[],int n)

{

cout


9/80

case 1:

coutsort characters

1Enter the elements

3

8

16

9

3The sorted array is :


10/80

1

3

36

8

91->sort integers2->sort doubles

3->sort characters

2Enter the elements

5.66

7.3

8.662.22

9.88

1.0The sorted array is :

1

5.66

2.227.3

8.66

9.881->sort integers

2->sort doubles

3->sort characters

3Enter the elements

c

om

p

a

qThe sorted array is :

a

mc

o

p

q1->sort integers

2->sort doubles

3->sort characters4 */


11/80

Algorithm for Merge Sort

//This algorithm sorts the element taking high and low.

Algorithm merge_sort(low, high)

// Purpose: Sort the list in ascending order.// Input: A[0..n-1]the list to be sorted// nthe total number of elements.

//Output:A[0..n-1]the sorted list

{if low < high

{

mid (low + high)/2merge_sort(low,mid)

merge_sort(mid+1,high)merge(low,mid,high)

}}

Algorithm merge (low, mid, high)

// Purpose: Merge two sorted arrays where the first array starts from low to mid and the secondsstarts form mid + 1 to high.

// Input: A[0..n-1]is sorted from the index position low to mid.

// A[0..n-1]is sorted from the index position mid + 1 to high.

// nthe total number of elements.//Output:A[0..n-1]the sorted from index low to high.

{

h lowi low

j mid+1

while(h < = mid and j < = high)

{

if A[h] < = A[j] then B[i] A[h]

h h+1else

B[i] A[j]

j j+1

}


12/80

if (h > mid) then

{

for (k j to high) do

B[i] A[k]

j i+1

}

else{

for k h to mid do

B[i] A[k]

j i+1\

}

for (k low to high) do

A[k] B[k]}

Time complexity of Merge Sort (n log2 n)


13/80

/* 3.a) Sort a given set of elements using Mergesort method.*/

#include#include

void merge(int a[],int low,int mid,int high){int i,j,k,c[20];

k=low;

i=low;j=mid+1;

while((i


14/80

cout


15/80

Algorithm to check whether a given graph is connected or not using Depth First Search

Algorithm test connected( )//Purpose: To check whether given graph is connected or not using DFS

//Input: A[][]adjacency matrix of the given graph

nnumber of nodes in the graphvfrom where the traversal is to be initiatedreach[] - indicate the vertices that are visited and that are not visited.

//Output: The graph is connected or not connected

{read v

dfs(v)

for i 1 to n do{

if(reach[i]!=1){

Print not ConnectedExit(0);}

print Connected

}}

void dfs(v){

reach[v] 1

for i 1 to n do{if (A[v][i])

{

if(!reach[i])dfs(i)

}

}

}

Time complexity of DFS is ( |V

2

| )


16/80

/* 3. b)Check whether a given graph is connected or not using DFS method.*/

#include

#include

class graph //Class declaration{

private : int a[20][20],reach[10];

int n;

public: void read()

{

coutn;

cout


17/80

for(int i=0;i


18/80

Algorithm for Selection Sort

Algorithm selection_sort (A[0..n-1])// Purpose: Sort the list in ascending order.

// Input: A[0..n-1]the list to be sorted

// nthe total number of elements.//Output:A[0..n-1]the sorted list{

for i 0 to n-2 do{

min i;

for j i+1 to n-1 do{

if A[j]


19/80

/*4) Sort a given set of element using selection sort and hence find time required to sort

element */

#include

#include

#include#include

template

void sel(T a[],int n){

int min;

T temp;

for(int i=0;i


20/80

cout


21/80

/* OUTPUT

Enter the Number of elements

61->Sort integers

2->Sort doubles

3->Sort characters1Enter the elements

4

61

8

2


1

24

6

8

9Time taken for sorting : 5.8667e-06

1->Sort integers

2->Sort doubles3->Sort characters

2

Enter the elements

2.32.4

1.2

7.76.5

9.2

The sorted array is :

1.22.3

2.4

6.57.7

9.2

Time taken for sorting : 1.6762e-05

1->Sort integers2->Sort doubles

3->Sort characters

3Enter the elements


22/80

c

o

mp

a

qThe sorted array is :a

c

mo

p

q

Time taken for sorting : 4.1905e-061->Sort integers

2->Sort doubles

3->Sort characters0

*/


23/80

Algorithm for Topological Ordering

Topological_Order ( )//Purpose: To obtain the sequence of jobs to be executed resulting in Topological order.

//Input: A- adjacency matrix of the given graph.

n- the no. of vertices in the graph.//Output: v-indicates the jobs that are to be executed in the order.{

stack s

for i 0 to n do{

for (int j 1 to n do)if (A[i][j] )

+ + indegree[j]

}

for i 1 to n do

{if (indegree[i]= = 0)

{s.push(i)

reach[i] 1

}}

while (!s.empty ( ))

{

temp s.pop( )

v[++ count] tempfor j 1 to n do{

if (A[temp][j]){

if(!reach[j])

reach[j] 1

indegree[j]if(!indegree[j])

s.push( j )

}

}}

Time complexity of Topological Order is ( |V2| )


24/80

/* 5.a) Obtain the Topological ordering of vertices in a digraph.*/

#include#include

#define MAX 5

class stack //Declaration of class stack{

Private :int a[MAX], top;

public:

stack();

void push(int); //Basic stack functions

int pop();int empty();

};

stack::stack()

{

for(int i=0;i


25/80

temp=a[top];

top--;

}return temp; //Returns the popped element}

int stack::empty(){

if(top==-1)

return 1;else

return 0;

}

void topological() //Function for topological sort

{

stack s;int a[30][30],temp, i, j;

int count=0,v[30],reach[30],indegree[30],n;

cout


26/80

{

temp=s.pop(); //Pop an element from stack

v[++count]=temp; //assign temp to vfor(j=1;j


27/80

Algorithm for Insertion Sort

Algorithm insertion_sort (A[0..n-1])

// Purpose: Sort the list in ascending order.// Input: A[0..n-1]the list to be sorted// nthe total number of elements.

//Output:A[0..n-1]the sorted list

{

for j 0 to n-1{

item A[i]

j i-1while(j > = 0 and item < A[j]){

A[j+1] A[j]j j - 1

}

A[j+1] item

}

}

Time complexity of Insertion Sort in Best case is (n)Time complexity of Insertion Sort in Worst case is O(n

2)

Time complexity of Insertion Sort in Average case is (n2)


28/80

/* 5. b)Sort a given set of elements using Insertion sort method.*/

#include#include

void insert_sort(int a[],int n){int i,j,item;

for(i=0;i=0 && item


29/80

Algorithm for Knapsack Problem

Algorithm Knapsack / ele,rem_cap, reach[ ])//Purpose: to solve knapsack problem using dynamic programming.

//Input: nthe no. of objects to be selected.

m- the capacity of the knapsackw- weights of all the objects.pprofits of all the objects.

//Output: the optimal solution for the no. of objects selected with specified remaining capacity.

if ( ele num-1)if (amount[ele] rem_cap )

return (rec(ele +1, rem+cap,reach))reach1[10]

for i 0 to num

reach1[i] reach[i]

reach1[ele] 1

a rec(ele+1,rem_cap-amount[ele],reacb1) + prof[ele]

b rec(ele+1,rem_cap,reach)if max(a,b)

for i 0 to num

reach[i] reach1[i]return a

return b

Time complexity of Knapsack Problem is (mn)


30/80

/* 6) Implement 0/1 Knapsack problem using dynamic programming.*/

#include #include

#include

class knapsack{

private: int profits[30];

int weights[30]; //v->Optimal solution matrixint n,m,v[30][30]; //m->capacity,n->no.of elements

public:

getdata()

{coutn;

cout


31/80

}

int max1(int a,int b){

if(a>b)

return a;elsereturn b;

}

void display()

{

int optsoln; //stores the optimal solution

optsoln = mfk(n,m);int a=n;

int b=m;

cout0{

if(v[a][b]!=v[a-1][b]) //if v[i][j]!=v[i-1][j]

{cout


32/80

/*

OUTPUT :

Enter the no of objects: 5Enter the weights:

3 9 1 5 2

Enter the profits :56 34 2 56 43Enter the knapsack capacity: 10

{ 5 4 1 }

Optimal solution = 155

Enter the no of objects: 4

Enter the weights:2 1 3 2

Enter the profits :

12 10 20 15Enter the knapsack capacity: 5

{ 4 2 1 }

Optimal solution = 37

*/


33/80

Dijkstras Algorithm

Algorithm Dijkstra (G)//Purpose: To find the shortest path from the starting vertex to other vertices.

//Input: A weighted connected graph G=

//Output: The length of shortest path from starting vertex to other vertices.{

for i 1 to n

s[i] 0

dist[i] cost[v][i]

s[v] 1

dist[v] 0

num 2while ( num < = n)

u choose( )

s[u] 1

num++for i w to nif (((dist[u] + cost[u][w]) < dist[w] ) && (!s[w]))

dist [w]=dist [u] + cost [u][w]

}

//Algorithm to choose the nearest non selected vertex from a particular vertex

Algorithm choose ( )

{

j 1

min 1000

for (dist[w] < min) &&(!s[w]))min dist[w]

j wreturn ( j )

}

Time complexity of Dijkstras Algorithm is (E log V)


34/80

/* 7) From a given weighted connected graph, find the shortest paths to other vertices,

using Dijkstras algorithm.*/

#include

#include

class dijkstras{

public:int n,v,dist[10],cost[10][10];

void read();

void shortest_path(int v,int cost[10][10],int dist[10],int n);

int choose(int dist[10],int s[10],int n);void disp();

};

void dijkstras::read()

{

int i,j;cout


35/80

{

int u=choose(dist,s,n); //choose a vertex which is

//nearer to vs[u]=1; //mark it as visitednum++;

for(int w=1;wcurrent edge length

//cost[u][w]->edge length from u to other vertices

//dist[w]->w indexes dist which gives the distance

//from the first vertexif(dist[u]+cost[u][w]


36/80

void main()

{dijkstras d;

clrscr();

d.read();d.shortest_path(d.v,d.cost,d.dist,d.n);d.disp();

getch();

}

/*

OUTPUT :

Enter the no of vertices4

Enter the cost of adjacency matrix

0 10 15 255 0 2 1000

1000 1000 0 13

10 1000 1000 0

Enter the starting vertex1

Node 2 is at the distance of : 10 from 1

Node 3 is at the distance of : 12 from 1Node 4 is at the distance of : 25 from 1

*/


37/80

Algorithm for Quick SortAlgorithm partition(m, p)

// Purpose: Partition the array into two parts such that elements towards left of the key elementare less than the key element and the elements towards right of the key element

are greater than the key element.

// Input: A[0..n-1]is a unsorted from the index position low to high.//Output: A[0..n-1]is divided into two parts as told above.{

A[m],A[m+1],..A[p-1])

v A[m] //pivot element

i m

do{

do

{

i i+1

}while(A[i] > = v)do

{

p p-1

}while(A[p]< = v)

if i < pswap (A[i],A[p])

else

break

}while(1)

A[m] A[p]

A[p] vreturn p

}Algorithm quick_sort(p,q)

// Purpose: Sort the elements of the array between the lower bound and upper bound.

// Input: A[0..n-1]the list to be sorted with low and high as lower bound and upper bound

// nthe total number of elements.//Output:A[0..n-1]the sorted list

{

A[n+1]if(p < q)

then j q+1partition (p,j)

quick_sort(p,j-1)

quick_sort(j+1,q)}

Time complexity of Quick Sort in Best case is (n log2 n)

Time complexity of Quick Sort in Worst case is O(n2)

Time complexity of Quick Sort in Average case is (n log2 n)


38/80

/* 8) Sort a given set of elements using Quicksort method.*/

#include#include

#include //Inclusion of header files

template //Template functionint partition(T a[],int low,int high)

{

int i=low+1,j=high;T temp;

while(1)

{

while(ia[i])i++;while(a[low]


39/80

template //Display template functionvoid disp(D a[],int n)

{cout


40/80

default:exit(0);

break;

}}

getch();

}

/*

OUTPUT :enter the number of elements

6

1->sort integers2->sort doubles

3->sort characters

1Enter the elements

3

2

41

6


1

2

34

5

61->sort integers

2->sort doubles

3->sort characters

2Enter the elements

2.1

3.51.2

5.2

6.2

4.4The sorted array is :

1.2

2.13.5


41/80

4.4

5.2

6.21->sort integers

2->sort doubles

3->sort characters3Enter the elements

c

om

p

a

qThe sorted array is :

a

cm

o

p

q1->sort integers

2->sort doubles

3->sort characters0

*/


42/80

Kruskals Algorithm

Algorithm Kruskal(G)

//Kruskals Algorithm for constructing a minimum spanning tree.//Input: A weighted connected graph G=( V,E)

//Output: ET, the set of edges composing a minimum spanning tree of G

Sort E in non-decreasing order of the edge weights

W(ei1) W( ei |E|)

ET ; //initialize the set of tree edges

ecounter 0 //inititalize the size of tree

k 0 //initialize the no of processed edges

while ecounter < |V| -1

k k + 1if ET U{eik} is a cyclic

ET ET U{eik}Ecounter ecounter + 1

return ET

With an efficient sorting algorithm the

Time complexity of Kruskals Algorithm is O( |E| log |E| )


43/80

/* 9) Find minimum cost spanning tree of a given undirected graph using Kruskal's

algorithm*/

#include

#include

#define max 10

struct ec //structure to store each edge

{

int weight,u,v;};

class kruskal //class kruskal declaration

{private:int e,n,cost[max][max],parent[10];

struct ec edge[max*max];

public: //member functionsvoid getdata();

void stree();

void minheapcreate();

struct ec minheapdelete();void adjust(int i,int g);

int find(int i);

void uniont(int i,int j);};

void kruskal::getdata() //input function

{e=1;

cout


44/80

}

}

}

void kruskal::stree()

{int mincost=0,i=0,T[max][2],ne=0;struct ec temp;

for(int s=1;s


45/80

{

int k=i;

int j=k*2;struct ec item;

item.u=edge[i].u;

item.v=edge[i].v;item.weight=edge[i].weight;while(j


46/80

int kruskal::find(int i) //find parent node

{

while(parent[i])i=parent[i];

return i;

}

void kruskal::uniont(int i,int j) //joins an edge to tree

{

parent[j]=i;}

void main() //begin of main

{kruskal k;

clrscr();

k.getdata();k.stree();

getch();

} //end of main/* OUTPUT :

RUN1:

Enter the number of vertices:6Enter the weighted adjacancy matrix:0 10 1000 1000 11 100010 0 10 1000 8 9

1000 10 0 1000 1000 5

1000 1000 1000 0 12 711 8 1000 12 0 71000 9 5 7 7 1000Minimum cost = 37

6--->36--->4

6--->55--->2

2--->1

RUN2:

Enter the number of vertices:

4

Enter the weighted adjacancy matrix:1000 40 60 1040 1000 10 2060 10 1000 30

10 20 30 1000Minimum cost = 404--->13--->24--->2 */


47/80

Algorithm for Breath First Search

Algorithm BFS ( )//Purpose: Traverse the graph form the given source node.

//Input: A[][]adjacency matrix of the given graphnnumber of nodes in the graphvfrom where the traversal is to be initiated

reach [ ]- indicate the vertices that are visited and that are not visited.

//Output: the vertices, which are reachable and not reachable from the source node

{

read v

print Vertices reachable are

insert (v)

reach[v] 1

while (! Empty ( )){

int n delete( )

for j 1 to n do

{

if (A[u][j]){

if (!reach[j])

{

reach[j] 1insert (j)

print j}

}}

}

}

Time complexity of BFS is ( |V2| )


48/80

/* 10.a)Print all the nodes reachable from a given starting node in a digraph using BFS

method.*/#include#include

#include

#include

const int max=20;

int a[20][20], reach[20], n; //Global declaration

class QUEUE //declaration of class queue

{

Private : int q[max];

int f,r;public:

QUEUE();

void insert(int x);int del();

int empty();

void bfs();

};

QUEUE::QUEUE()

{f=0; //Initialize front and rear=0r=-1;

}

void QUEUE::insert(int x)

{

if(r==max-1)cout


49/80

else

{

a=q[f++];return a;

}

}

int QUEUE::empty()

{

if(f>r) //If front>rear then reset f,r{

f=0;

r=-1;

}if(r==-1)

return 1;

elsereturn 0;

}

void QUEUE:: bfs(){

int v;

coutv;

insert(v); //Initialize a queue with vreach[v]=1; //Mark v as reached

cout


50/80

void main()

{QUEUE B;

int i, j;

clrscr();coutn;

cout


51/80

Floyds Algorithm

Algorithm Floyd (W[1n, 1.n])

//Purpose: Implements Floyds algorithm for the all pairs shortest paths problem.

//Input: The weight matrix W of a graph.

//Output : The distance matrix of the shortest paths length.D = W // is not necessary if W can be overwritten

for k 1 to n do

for i 1 to n do

for j 1 to n do

D[i,j] min {D [i,j], D[i,k]+D[k,j]}

return D

Time complexity of Floyds Algorithm is ( n3

)


52/80

/* 10.b) Implement all pairs shortest paths of the problem using FLOYD'S

ALGORITHM.*/

#include //Header Files#include

#include#include#include

class floyd{ //a->adjacency matrix,r->resultant matrixprivate : int a[20][20],r[20][20],n;

public:

floyd(){

n=0;

}int cal(int,int,int);

void read();

void disp();

int min(int,int);void shortest();

};

void floyd::read()

{

int i,j;

coutn;

cout


53/80

int floyd::min(int x,int y) //Function to calculate{ //minimum of 2 pathsif(x


54/80

7 7 0 16 16 9 0 */

Algorithm for Sum of SUBSET

Algorithm Sum of Sub (s, k, r)

// Purpose: To find sum of subset is equal to given value

//Input: sis a given setdis sum of subset

//Output: getting the subsets whose sum value is equal to d.

{

if k < = n

x[k] 1

if s + w[k] d

{

p++

print solution vector is

for j 1 to nprint x[j]

}else

if (s + w[k] + w [k+1]


55/80

*11) Find the subset of the given set S={S1,S2,.....,Sn} of n positive integer whose sum is

equal to the given positive integer,a suitable message is to be displayed if the given problem

instance have no solution.*/


#include

#include#include

int p=0;

class subset{

private: int x[20],w[20]; //x[]->Flag array to indicate

int d,n; //element is selected.//w[]->Set of weighted elementspublic: //d->Subset generation constraint

subset(); //(max weight allowed in subset)

//number of elements in the setvoid sumofsub()

{

sumofsub(0,1,d);}

void sumofsub(int,int,int);

void read();

};

//constructor

subset::subset(){

int i;

coutn;cout


56/80

p++; //count to indicate any subset generatedcout


57/80

{ 5 12 13 }{ 8 10 12 } */

Horspools Algorithm

Algorithm shift table(p[0m-1])

//Purpose: fills the shift table used by Horspools algorithm

//Input: Pattern p[0.m-1] and an alphabet of possible characters.//Output: Table [0size-1] indexed by the alphabets

//Characters and filled with shift sizes computed by formula

Initialize all the elements of length with m

For j 0 to m-2 do Table [p[j]] = m-1-jReturn Table

Algorithm Horspool Matching[p[0m-1], T[0n-1])

//purpose: Implements Horspools algorithm for string matching//Input: The index of the left end of the first matching substring or1 if there are no matches.

Shift table(p[0.m-1]) // generate Table of shifts

i m-1 // position of the patterns right end

while i


58/80

/* 12.a) Implement Horspool algorithm for string matching. */

#include#include

#include

#include

class HORSPOOL

{

private:int m,n; //p ->Substring, s-> Textchar p[30],s[50],T[50]; //T-> Shift Table

public:

void get() //M.F to scan string and substring{

cout


59/80

int index;

m=strlen(p); //String length of substringn=strlen(s); //String length of textshift_table();

int i=m-1; //initialize I to m-1 i.e, last

//but one character of substringwhile(i


60/80

Algorithm to compute Binomial Co-efficient

Algorithm Binominal (n,k)//Purpose: Computes c(n,k) by the dynamic programming algorithm.

//Input : a pair of non negative integers n >= k>=0

//Output : The value of c(n,k)for i 0 to n do

for j 0 to min(i,k) doif ( j=0 || j=k)

c[i , j] 1else

c[i , j]=c[i-1,j-1] + c[i-1,j]return c[n , k]

Time complexity of Binomial Co-efficient is ( nk )


61/80

/*12.b) Find The Binomial Co-Efficient Using Dynamic Programming*/


#include

#include#includeclass BINOMIAL

{

private : int n,k;public :

void read()

{

coutn;

coutk;}

int min(int a,int b)

{

return a


62/80

/*int min(int n,int m)

{

return((n


63/80

Prims Algorithm

Algorithm PRIM(G)

//Purpose: Prims algorithm for constructing a minimum spanning tree

//Input: A weighted connected graph G = (V,E)

//Output: ET, the set of edges composing a minimum spanning tree of G

VT { V0} // the set of tree vertices can be initialized with any vertex.

ET

For i 1 to |V| -1 do//find a minimum weight edge e* (V*,U*)

//among all the edges (V,U) such that V in VT and U is in V-VT

VT VT U {U*}

ET ET U {e*}return ET

Time complexity of Prims Algorithm is ( |V2

| )


64/80

/* 13) Find minimal cost spanning tree of a given undirected graph using prims

algorithm.*/

#include

#include //Header file

#include

const int max=20; //declaration of constantconst int ne=1000; //ne->indicates no edge

//Definition of the graph

class graph

{

private: //private data member

int a[max][max],n; //adjacency matrixint reach[max]; //Array to check whether i is

// included n the spanning treeint close[max]; //Taken to find a vertex which

// is having mincost edge from iint r[2][max]; //Array containing spanning tree

public:

graph();

void read();

void disp();void prim();

};

graph::graph() //constructor

{

int i;

for(i=0;i


65/80

cin>>a[i][j];

}

void graph::disp() //Function to display the matrix

{int i,j;cout


66/80

for(j=1;j


67/80

g.prim();

getch();

}

/*

OUTPUT:

ENTER THE GRAPH

ENTER THE TOTAL NUMBER OF VERTICES IN THE GRAPH

4ENTER THE ADJACENCY MATRIX OF THE GRAPH

1000 1 5 3

1 1000 1000 1000

5 1000 1000 23 1000 2 1000

THE ADJACENCY MATRIX IS

1000 1 5 31 1000 10000 1000

5 1000 1000 2

3 1000 2 10000

THE VERTICES IN THE SPANING TREE ARE1--2

4--1

3--4THE TOTAL COST OF THE SPANING TREEE IS 6

2nd

RUN:

ENTER THE GRAPH

ENTER THE TOTAL NUMBER OF VERTICES IN THE GRAPH4

ENTER THE ADJACENCY MATRIX OF THE GRAPH

1000 1000 10 301000 1000 1000 1000

10 1000 1000 20

30 1000 20 1000

THE ADJACENCY MATRIX IS1000 1000 10 30

1000 1000 1000 1000

10 1000 1000 2030 1000 20 1000

THE GRAPH IS DISCONECTED

*/


68/80

To print the reachable nodes using Depth First Search

Algorithm test connected ( )//Purpose: Traverse the graph form the given source node.

//Input: A[][]adjacency matrix of the given graph

nnumber of nodes in the graphvfrom where the traversal is to be initiatedreach [ ]- indicate the vertices that are visited and that are not visited.

//Output: the vertices, which are reachable and not reachable from the source node

{print Enter the starting vertex

read V

dfs(V)

}

Algorithm dfs(V)

{ reach[V] 1cout>>V

for i 1 to n do

{if(A[V][i])

{

if(!reach[i])

dfs(i)}

}

}

Time complexity of DFS is ( |V2| )


69/80

/* 14.a)Print All Nodes Reachable From A Given Starting Nodes In A

Given Digraph Using Depth First Search Method*/

#include

#include //Header file

#include

class graph //defination of the class{

private: //data memeber

int a[20][20],reach[20],n;

public: //member function

void intialise();void read();

void disp();

void testcondition();

void DFS(int v);

};

//Function to initialize reach

void graph::intialise()

{for(int i=0;i


70/80

//Function to display the matrix

void graph::disp(){

int i,j;

cout


71/80

/**********MAIN FUNCTION**********/

main(){

clrscr();

int p;graph G;G.read();

G.testcondition();

G.disp();getch();

return(0);

}

/* OUTPUT:

Enter the total number of vertices

4

Enter the adjacency matrix of the digraph

0 1 0 1 0 0 0 0 1 0 0 0 0 1 1 0

The vertices reachable from 1 are: 2 4 3

The vertices reachable from 2 are:

The vertices reachable from 3 are: 1 2 4The vertices reachable from 4 are: 2 3 1

The adjacency matrix of the given digraph is

0 1 0 1

0 0 0 01 0 0 0

0 1 1 0

Enter the total number of vertces

3

Enter the adjacency matrix of the digraph

0 1 1 0 0 1 0 0 0

The vertices reachable from 1 are: 2 3

The vertices reachable from 2 are: 3

The vertices reachable from 3 are:

The adjacency matrix of the given digraph is0 1 1

0 0 1

0 0 0 */


72/80

Warshalls Algorithm

Algorithm warshall ( A[1n,1..n])

//Purpose: Implements warshalls algorithm for computing the transitive closure//Input: the adjacency matrix A of a diagraph with n vertices.

//Output: The transitive closure of the diagraph

R(0)

A

for k 1 to n do

for i 1 to n do

for j 1 to n do

R(k)

[i , j ] R(k-1)

[i , j ] or R(k-1)

[i , k] and R(k-1)

[k , j]return R

(n)

Time complexity of Warshalls Algorithm is ( n3

)


73/80

/*14.b) Compute the transitive closure of a given directed

graph using washalls algorithm. */

#include //HEADER FILES#include

#include#include#include

class warshal{

private : int a[20][20],r[20][20][20],n;

//a[][]->adjacency matrix

//r[][][]->resultant matrixpublic:

warshal()

{n=0;

}

void cal();void read();

};

void warshal::read()

{

int i,j;

coutn;

cout


74/80

//r[k-1][i][j]->intermediate vertices numbered not more than k-1

//2nd

condition if intermediate vertices numbered not more than k-1

//from r[i][k] to k and k to r[k][j].

cout


75/80

Queens Problem

Algorithm Camplace (int k, int i)//Purpose: To place the Queen on Chess board (Such that, no two queens are placed in same row,

//same column and diagonal.

//Input: n - Numbers of Queens//Output: Solution Queens are placed on Chess board.{

for j 1 to k do{

if ((x[j] = i) || ((fabs (x[j]-i))) == (fabs (jk)))return false

}

return true;

}

Algorithm n_queens (int k){

for i 1 to n do

{

if(complace (k , i)){

x[k]=i;

if(k = = n)

{display( );

}

else n_queens(k+1);}

}

}

Algorithm display( )

{

for i 1 to n do{

for j 1 to n do

{ if (j = x[i])

board [i][j] 0else

board[i][j] *

}}


76/80

for i 1 to n do

for j 1 to n do{

print board[i][j];}

exit(1);}

}}

Time complexity of Queens Algorithm is (nk)


77/80

/* 15) Implement N Queen's problem using Back Tracking.*/

#include#include

#include

#include

int n;

class queen //class declaration{

private : int x[20]; //datachar board[10][10];

public :

int canplace(int,int); //member functions

void nQueens(int);void display();

};

int queen::canplace(int k,int i){

for(int j=1;jchecks rows and columns for attack

//while fabs(x[j]-i)==fabs(j-k) is to check diagonal attack

if((x[j]==i)||((fabs(x[j]-i))==(fabs(j-k))))

return 0;

}return 1;

}

void queen::nQueens(int k)

{//If i has reached n, we have a valid soln

for(int i=1;i


78/80

}

else

nQueens(k+1); //recursively call nqueens()

} //till i reaches n}}

void queen::display() //function to display

{int i,j;

for( i=1;i


79/80

/*

OUTPUT:******OUTPUT 1******

enter the no. of queens6

*Q****

***Q*******Q

Q*****

**Q***

****Q*******OUTPUT 2******

enter the no. of queens

4*Q**

***Q

Q***

**Q*

*/


80/80

ada lab progs

Documents