SA

Design and Analysis of

Algorithms
Subject Code: 18CSL47

Lab Manual
1. Sort a given set of elements using the Quicksort method and determine the time
rEQuired to sort the 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.
The elements can be read from a file or can be generated using the random number
generator.

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

void Exch(int *p, int *q)

{
int temp = *p;
*p = *q;
*q = temp;
}

void QuickSort(int a[], int low, int high)

{
int i, j, key, k;
if(low>=high)
return;
key=low; i=low+1; j=high;
while(i<=j)
{
while ( a[i] <= a[key] ) i=i+1;while (
a[j] > a[key] ) j=j-1;
if(i<j) Exch(&a[i], &a[j]);
}
Exch(&a[j], &a[key]); QuickSort(a, low, j-
1); QuickSort(a, j+1, high);

void main()
{ int n, a[1000],k;
 clock_t st,et;
double ts;
clrscr();
printf("\n Enter tfow many Numbers: ");scanf("%d",
&n);
printf("\nThe Random Numbers are:\n");for(k=1;
k<=n; k++)
{
a[k]=rand();
printf("%d\t",a[k]);
}
st=clock(); QuickSort(a,
1, n);et=clock();
ts=(double)(et-st)/CLOCKS_PER_SEC;
printf("\nSorted Numbers are: \n "); for(k=1;
k<=n; k++)
printf("%d\t", a[k]); printf("\nThe time
taken is %e",ts);getch();

}
Output:
 2. sort a given set of elements Using Merge Sort algorithm and determine the
time reQuired to sort the 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. The elements can be read from a file or can be generated using the random
number generator.

# include <stdio.h> #
include <conio.h>
#include<time.h>
void Merge(int a[], int low, int mid, int high)
{
int i, j, k, b[20]; i=low;
j=mid+1; k=low;
while ( i<=mid && j<=high )
{
if( a[i] <= a[j] )
b[k++] = a[i++] ;
else
b[k++] = a[j++] ;
}
while (i<=mid) b[k++] = a[i++] ;
while (j<=high) b[k++] = a[j++] ;
for(k=low; k<=high; k++)a[k] =
b[k];
}
void MergeSort(int a[], int low, int high)
{
int mid; if(low >=
high)
return;
mid = (low+high)/2 ;
MergeSort(a, low, mid);
MergeSort(a, mid+1, high);
Merge(a, low, mid, high);
}
void main()
{
 int n, a[2000],k;
clock_t st,et; double
ts; clrscr();
printf("\n Enter tfow many Numbers:");scanf("%d",
&n);
printf("\nThe Random Numbers are:\n");for(k=1;
k<=n; k++)
{
a[k]=rand();
printf("%d\t", a[k]);
}
st=clock(); MergeSort(a,
1, n);et=clock();
ts=(double)(et-st)/CLOCKS_PER_SEC; printf("\n
Sorted Numbers are : \n ");for(k=1; k<=n; k++)
printf("%d\t", a[k]); printf("\nThe time
taken is %e",ts);getch();
}
Output:
3. Obtain the Topological ordering of vertices in a given digraph.

#include<stdio.h>
#include<conio.h>
int a[10][10],n,indegre[10];void
find_indegre()
{ int j,i,sum;
for(j=0;j<n;j++)
{
sum=0;
for(i=0;i<n;i++)
sum+=a[i][j];
indegre[j]=sum;
}
}
void topology()
{
int i,u,v,t[10],s[10],top=-1,k=0;
find_indegre();
for(i=0;i<n;i++)
{
if(indegre[i]==0) s[++top]=i;
}
while(top!=-1)
{
u=s[top--]; t[k++]=u;
for(v=0;v<n;v++)
{
if(a[u][v]==1)
{
indegre[v]--; if(indegre[v]==0)
s[++top]=v;
}
}
}
printf("The topological Sequence is:\n");
for(i=0;i<n;i++)
printf("%d ",t[i]);
}
void main()
{
int i,j;
clrscr();
printf("Enter number of jobs:");
scanf("%d",&n);
printf("\nEnter the adjacency matrix:\n");
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
scanf("%d",&a[i][j]);
}
topology();
getch();
}

Output:
4. Write a program in C to find shortest paths to other vertices usingDijkstra's
algorithm.

#include<stdio.h>
#include<conio.h> #define
infinity 999
void dij(int n,int v,int cost[10][10],int dist[100])
{
int i,u,count,w,flag[10],min;
for(i=1;i<=n;i++)
flag[i]=0,dist[i]=cost[v][i];
count=2;
while(count<=n)
{
min=99;
for(w=1;w<=n;w++)
if(dist[w]<min && !flag[w])
min=dist[w],u=w;
flag[u]=1; count++;
for(w=1;w<=n;w++)
if((dist[u]+cost[u][w]<dist[w]) && !flag[w])
dist[w]=dist[u]+cost[u][w];
}
}

void main()
{
int n,v,i,j,cost[10][10],dist[10];clrscr();
printf("\n Enter the number of nodes:");
scanf("%d",&n);
printf("\n Enter the cost matrix:\n");
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
scanf("%d",&cost[i][j]);
if(cost[i][j]==0)
cost[i][j]=infinity;
 }
printf("\n Enter the source matrix:");
scanf("%d",&v);
dij(n,v,cost,dist);
printf("\n Shortest path:\n");
for(i=1;i<=n;i++)
if(i!=v)
printf("%d->%d,cost=%d\n",v,i,dist[i]);
getch();
}

Output:
 5. Find Minimum Cost Spanning Tree of a given undirectedgraph using
Kruskal's algorithm.

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int i,j,k,a,b,u,v,n,ne=1;
int min,mincost=0,cost[9][9],parent[9];
int find(int); int
uni(int,int);void
main()
{
clrscr();
printf("\n\n\tImplementation of Kruskal's algorithm\n\n");printf("\nEnter the no.
of vertices\n");
scanf("%d",&n);
printf("\nEnter the cost adjacency matrix\n");
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
scanf("%d",&cost[i][j]);
if(cost[i][j]==0)
cost[i][j]=999;
}
}
printf("\nThe edges of Minimum Cost Spanning Tree are\n\n");while(ne<n)
{
for(i=1,min=999;i<=n;i++)
{
for(j=1;j<=n;j++)
{
if(cost[i][j]<min)
{
min=cost[i][j];
a=u=i;
b=v=j;
}
 }
}
u=find(u);
v=find(v);
if(uni(u,v))
{
printf("\n%d edge (%d,%d) =%d\n",ne++,a,b,min);mincost
+=min;
}
cost[a][b]=cost[b][a]=999;
}
printf("\n\tMinimum cost = %d\n",mincost);getch();
}
int find(int i)
{
while(parent[i])
i=parent[i]; return i;
}
int uni(int i,int j)
{
if(i!=j)
{
parent[j]=i;
return 1;
}
return 0;
}
Output:
9. 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. For example, if S={1, 2, 5, 6, 8} and d = 9 there are
two solutions {1,2,6} and
{1,8}.A suitable message is to be displayed if the given problem instance doesn't have
a solution.

#include<stdio.h>
#include<conio.h> int
s[10] , x[10],d ;
void sumofsub ( int , int , int ) ;void main ()
{
int n , sum = 0 ;int i ;
clrscr () ;
printf ( " \n Enter the size of the set : " ) ;scanf ( "%d" ,
&n ) ;
printf ( " \n Enter the set in increasing order:\n" ) ;for ( i = 1 ; i <= n ;
i++ )
scanf ("%d", &s[i] ) ;
printf ( " \n Enter the value of d : \n " ) ;
scanf ( "%d" , &d ) ;for ( i
= 1 ; i <= n ; i++ )
sum = sum + s[i] ;if (
sum < d || s[1] > d )
printf ( " \n No subset possible : " ) ;
else
sumofsub ( 0 , 1 , sum ) ;
getch () ;
}
void sumofsub ( int m , int k , int r )
{
int i=1 ; x[k]
=1;
if ( ( m + s[k] ) == d )
{
printf("Subset:");
for ( i = 1 ; i <= k ; i++ )
 if ( x[i] == 1 )
printf ( "\t%d" , s[i] ) ;printf (
"\n" ) ;
}
else if ( m + s[k] + s[k+1] <= d )
sumofsub ( m + s[k] , k + 1 , r - s[k] ) ;
if ( ( m + r - s[k] >= d ) && ( m + s[k+1] <=d ) )
{
x[k] = 0;
sumofsub ( m , k + 1 , r - s[k] ) ;
} }

Output:
7. Implement any scheme to find the optimal solution for the Traveling Salesperson
problem and then solve the same problem instance using any approximation algorithm
and determine the error in the approximation.
6. Find Minimum Cost Spanning Tree of a given undirected graph
using Prim’s algorithm.

#include<stdio.h>
#include<conio.h> int
a,b,u,v,n,i,j,ne=1;
int visited[10]={0},min,mincost=0,cost[10][10];void main()
{
clrscr();
printf("\n Enter the number of nodes:");
scanf("%d",&n);
printf("\n Enter the adjacency matrix:\n");
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
scanf("%d",&cost[i][j]);
if(cost[i][j]==0)
cost[i][j]=999;
}
visited[1]=1;
printf("\n");
while(ne<n)
{
for(i=1,min=999;i<=n;i++)
for(j=1;j<=n;j++)
if(cost[i][j]<min)
if(visited[i]!=0)
{
min=cost[i][j];
a=u=i;
b=v=j;
}
if(visited[u]==0 || visited[v]==0)
{
printf("\n Edge %d:(%d %d) cost:%d",ne++,a,b,min);
mincost+=min;
visited[b]=1;
}
 cost[a][b]=cost[b][a]=999;
}
printf("\n Minimun cost=%d",mincost);getch();
}

Output:
7. Implement All-Pairs Shortest Paths Problem using Floyd's
algorithm.

#include<stdio.h>
#include<conio.h> int
min(int,int);
void floyds(int p[10][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++)
if(i==j)
p[i][j]=0;
else
p[i][j]=min(p[i][j],p[i][k]+p[k][j]);
}
int min(int a,int b)
{
if(a<b)
return(a);
else
return(b);
}
void main()
{
int p[10][10],w,n,e,u,v,i,j;;clrscr();
printf("\n Enter the number of vertices:");
scanf("%d",&n);
printf("\n Enter the number of edges:\n");
scanf("%d",&e);
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
p[i][j]=999;
}
for(i=1;i<=e;i++)
 {
printf("\n Enter the end vertices of edge%d with its weight \n",i);
scanf("%d%d%d",&u,&v,&w);
p[u][v]=w;
}
printf("\n Matrix of input data:\n");
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
printf("%d \t",p[i][j]);
printf("\n");
}
floyds(p,n);
printf("\n Transitive closure:\n");
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
printf("%d \t",p[i][j]);
printf("\n");
}
printf("\n The shortest paths are:\n");
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
if(i!=j)
printf("\n <%d,%d>=%d",i,j,p[i][j]);
}
getch();
}
Output:
10. Implement N Queen's problem using Back Tracking.

#include<stdio.h>
#include<conio.h>
#include<math.h> int
a[30],count=0; int
place(int pos)
{
int i;
for(i=1;i<pos;i++)
{
if((a[i]==a[pos])||((abs(a[i]-a[pos])==abs(i-pos))))return 0;
}
return 1;
}
void print_sol(int n)
{
int i,j;
count++;
printf("\n\nSolution #%d:\n",count);
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
if(a[i]==j)
printf("Q\t");
else
printf("*\t");
}
printf("\n");
}
}
void queen(int n)
{
int k=1;
a[k]=0;
while(k!=0)
{
 a[k]=a[k]+1; while((a[k]<=n)&&!place(k))
a[k]++;
if(a[k]<=n)
{
if(k==n)
print_sol(n);
else
{ k++;
a[k]=0;

}
}
else
k--;
}
}
void main()
{
int i,n;
clrscr();
printf("Enter the number of Queens\n");
scanf("%d",&n);
queen(n);
printf("\nTotal solutions=%d",count);
getch();
}

Output: