1a.Recursivebinaryandlinearserach.

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<timer.h>
inta[20000],low,high,ele,pos;
intlin()
{
if(pos<0)
{
returnpos+1;
}
elseif(a[pos]==ele)
{
returnpos+1;
}
else
{
pos=pos1;
returnlin();
}
}
intbin()
{
intmid=(low+high)/2;
if(low>high)
{
return0;
}
if(a[mid]==ele)
{
returnmid+1;
}
elseif(a[mid]>ele)
{
high=mid1;
returnbin();
}

elseif(a[mid]<ele)
{
low=mid+1;
returnbin();
}
}
voidmain()
{
inti,n,temp;
Timert;
clrscr();
printf("\nEnterthenumberofelements");
scanf("%d",&n);
randomize();
printf("\nEnterthesearchelement");
scanf("%d",&ele);
printf("\nEnter1forlinearsearchand2forbinarysearch");
scanf("%d",&i);
if(i==1)
{
for(i=0;i<n;i++)
{
a[i]=rand();
}
pos=n1;
t.start();
temp=lin();
t.stop();
}
else
{
for(i=0;i<n;i++)
{
a[i]=i;
}
low=0;
high=n1;
t.start();;
temp=bin();

t.stop();
}
printf("\nElementfoundatposition=%dandtimetaken=%lf",temp,
(double)t.time());
getch();
}

2.Heapsort.
#include<stdio.h>
#include<timer.h>
#include<stdlib.h>
#include<conio.h>
voidheap(inta[],intn)
{
inti,j,k,temp;
for(i=2;i<=n;i++)
{
j=i;
k=j/2;
temp=a[j];
while(k>0&&a[k]<temp)
{
a[j]=a[k];
j=k;
k=k/2;
}
a[j]=temp;
}
}
voidheap1(inta[],intn)
{
inti,j,k,temp;
for(i=n/2;i>0;i)
{
k=i;
temp=a[k];
j=2*k;
while(j<=n)

{
if(j<n&&a[j]<a[j+1])
{
j=j+1;
}
if(temp<a[j])
{
a[k]=a[j];
k=j;
j=2*k;
}
else
{
break;
}
}
a[k]=temp;
}
}
voidadjust(inta[],intn)
{
inti=2,temp=a[1];
while(i<=n)
{
if(i<n&&a[i]<a[i+1])
{
i=i+1;
}
if(a[i]>temp)
{
a[i/2]=a[i];
i=i*2;
}
else
{
break;
}
}
a[i/2]=temp;

}
voidmain()
{
inta[10000],n,i,temp;
Timert;
clrscr();
printf("\nEnterthevalueofn");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
a[i]=ni;
}
t.start();
heap1(a,n);
for(i=n;i>=2;i)
{
temp=a[1];
a[1]=a[i];
a[i]=temp;
adjust(a,i1);
}
t.stop();
printf("\nTimetakenis%lf",t.time());
getch();
}

3.Mergesort.(method1)
#include<stdio.h>
#include<conio.h>
#include<timer.h>
#include<stdlib.h>
voidcopy(inta[],intb[],intst,intend)
{
inti;
for(i=st;i<end;i++)
{
b[ist]=a[i];
}

}
voidmerge(inta[],intn)
{
int*b,*c,i,j;
if(n==1)
{
return;
}
b=(int*)malloc(n/2);
copy(a,b,0,n/2);
merge(b,n/2);
c=(int*)malloc(n(n/2));
copy(a,c,n/2,n);
merge(c,n(n/2));
j=0;
for(i=0;(i+j)<n;)
{
if(j==n(n/2))
{
a[i+j]=b[i];
i=i+1;
}
elseif(i==(n/2))
{
a[i+j]=c[j];
j=j+1;
}
elseif(b[i]>c[j])
{
a[i+j]=c[j];
j=j+1;
}
else
{
a[i+j]=b[i];
i=i+1;
}
}
}

voidmain()
{
int*a,n,i;
Timert;
clrscr();
printf("\nEnterthevalueofn");
scanf("%d",&n);
a=(int*)malloc(n);
randomize();
for(i=0;i<n;i++)
{
a[i]=rand();
}
t.start();
merge(a,n);
t.stop();
printf("\nTimetaken=%lf",t.time());
getch();
}

3.Mergesort.(method2)
#include<stdio.h>
#include<conio.h>
#include<timer.h>
#include<stdlib.h>
#include<dos.h>
voidcopy(inta[],int*b,intst,intend)
{
inti;
for(i=st;i<=end;i++)
{
*(b+ist)=a[i];
}
}
voidmerge(inta[],int*b,int*c,intu)
{
inti,j=0,k=0;

for(i=0;i<=u;i++)
{
if(j<=(u/2)&&(k<=(u(u/2)1)))
{
if(*(b+j)>*(c+k))
{
a[i]=*(c+k);
k++;
}
else
{
a[i]=*(b+j);
j++;
}
}
elseif(j<=(u/2))
{
a[i]=*(b+j);
j++;
}
else
{
a[i]=*(c+k);
k++;
}
}
}
voidmergesort(inta[],intu)
{
int*b,*c,i;
if(u==0)
{
return;
}
b=(int*)malloc(((u/2)+1)*sizeof(int));
copy(a,b,0,u/2);
mergesort(b,u/2);
c=(int*)malloc(((u(u/2)))*sizeof(int));

copy(a,c,(u/2)+1,u);
mergesort(c,u(u/2)1);
merge(a,b,c,u);
free(b);
free(c);
}
voidmain()
{
int*a,i,n;
Timert;
clrscr();
printf("\nEnterthevalueofn");
scanf("%d",&n);
a=(int*)malloc(n);
randomize();
for(i=0;i<n/2;i++)
{
a[i]=2*i;
a[i+n/2]=2*i+1;
}
t.start();
mergesort(a,n);
t.stop();
printf("\nThevalueis%f",t.time());
getch();
}

4.Selectionsort.
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<malloc.h>
#include<timer.h>
voidsel(inta[],intn)
{
inti,j,temp,pos;
for(i=0;i<n1;i++)
{

pos=i;
for(j=i+1;j<n;j++)
{
if(a[j]<a[pos])
{
pos=j;
}
}
temp=a[i];
a[i]=a[pos];
a[pos]=temp;
}
}
voidmain()
{
int*a,n,i;
Timert;
clrscr();
printf("\nEnterthevalueofn");
scanf("%d",&n);
a=(int*)malloc(n);
randomize();
for(i=0;i<n;i++)
{
a[i]=rand();
}
t.start();
sel(a,n);
t.stop();
printf("\nTimetaken=%lf",t.time());
getch();
}

5a.Topologicalordering.
#include<stdio.h>
#include<conio.h>
voidmain()
{

inta[20][20],rem[20],ind,n,i,j,flag=0,t=0;
clrscr();
printf("\nEnterthevalueofn");
scanf("%d",&n);
printf("\nEntertheadjacencymatrix");
for(i=0;i<n;i++)
{
rem[i]=0;
for(j=0;j<n;j++)
{
scanf("%d",&a[i][j]);
}
}
while(flag==0)
{
flag=1;
for(i=0;i<n;i++)
{
if(rem[i]==0)
{
ind=0;
for(j=0;j<n;j++)
{
if(!(rem[j]==1||a[j][i]==0))
{
ind=1;
break;
}
}
if(ind==0)
{
printf("%s",t==0?"\nTopologicalorderingis":"");
rem[i]=1;
printf("%d",i+1);
flag=0;
t++;
break;
}
}

}
}
if(t!=n)
{
printf("\nTopologicalorderingisnotpossible(itcanonlybepartiallyordered)!!");
}
getch();
}

5b,14a.Floyd'salgorithm.
#include<stdio.h>
#include<conio.h>
voidmain()
{
inti,j,k,a[20][20],n;
clrscr();
printf("\nEnterthevalueofn");
scanf("%d",&n);
printf("\nEntertheadjacencymatrix");
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
scanf("%d",&a[i][j]);
}
}
for(k=0;k<n;k++)
{
for(j=0;j<n;j++)
{
for(i=0;i<n;i++)
{
a[i][j]=a[i][j]<(a[i][k]+a[k][j])?a[i][j]:(a[i][k]+a[k][j]);
}
}
}
printf("\nFloyd'sshortestpathis");
for(i=0;i<n;i++)

{
for(j=0;j<n;j++)
{
printf("%c%d",j==0?'\n':'',a[i][j]);
}
}
getch();
}

6.0/1knapsack.
#include<stdio.h>
#include<conio.h>
voidmain()
{
intp[20],w[20],kn[20][20],x[20],i,j,n,weight;
printf("\nEnterthevalueofn");
scanf("%d",&n);
printf("\nEnterthepriceoftheitems");
for(i=0;i<n;i++)
{
scanf("%d",&p[i]);
}
printf("\nEntertheweightoftheitems");
for(i=0;i<n;i++)
{
scanf("%d",&w[i]);
}
printf("\nEntertheweightoftheknapsack");
scanf("%d",&weight);
printf("\nTheknapsackis");
for(i=0;i<=n;i++)
{
printf("\n");
for(j=0;j<=weight;j++)
{
if(i==0||j==0)
{
kn[i][j]=0;

}
elseif(w[i1]>j)
{
kn[i][j]=kn[i1][j];
}
else
{
kn[i][j]=(kn[i1][j]>(kn[i1][jw[i1]]+p[i1]))?kn[i1][j]:(kn[i1][jw[i1]]+p[i1]);
}
printf("%d",kn[i][j]);
}
}
printf("\n\nTheoptimalsolutionis%d",kn[n][weight]);
i=n;
j=weight;
while(i!=0)
{
if(kn[i][j]==kn[i1][j])
{
x[i1]=0;
i=i1;
}
else
{
x[i1]=1;
j=jw[i1];
i=i1;
}
}
printf("\n\nThe0/1knapsackis");
for(i=0;i<n;i++)
{
printf("\nX[%d]=%d",i+1,x[i]);
}
getch();
}

7.Dijkstra'salgorithm.(method1)
#include<stdio.h>
#include<conio.h>
structprioq
{
intdist,pr,s;
};
voiddisplay(structprioqp[20],intsource,intdest,intd)
{
if(dest==source)
{
printf("%d",source);
return;
}
display(p,source,p[dest].s,d);
printf(">%d",dest);
}
voidmain()
{
structprioqp[20];
inti,j,n,k,min,pos,source,a[20][20];
clrscr();
printf("\nEnterthevalueofn");
scanf("%d",&n);
printf("\nEntertheadjacencymatrix");
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
scanf("%d",&a[i][j]);
}
p[i].pr=0;
}
printf("\nEnterthesourcenode");
scanf("%d",&source);
for(i=0;i<n;i++)
{
p[i].s=source;
p[i].dist=a[source][i];

}
pos=source;
for(j=0;j<n;j++)
{
i=pos;
p[i].pr=1;
min=9999;
for(k=0;k<n;k++)
{
if(p[i].dist+a[i][k]<p[k].dist)
{
p[k].dist=p[i].dist+a[i][k];
p[k].s=i;
}
if(p[k].pr!=1&&p[k].dist<min)
{
pos=k;
min=p[k].dist;
}
}
}
for(i=0;i<n;i++)
{
printf("\n");
if(i==source)
{
printf("%d>%d",source,source);
}
else
{
display(p,source,i,i);
}
printf("%d",p[i].dist);
}
getch();
}

7.Dijkstra'salgorithm.(method2)
#include<stdio.h>
#include<conio.h>
voiddisplay(intpar[],intsource,intdest1,intdest)
{
if(source==dest1&&dest1==dest)
{
printf("%d>%d",source,source);
return;
}
if(source==dest1)
{
printf("%d",source);
return;
}
display(par,source,par[dest1],dest);
printf(">%d",dest1);
}
voidmain()
{
intpar[20],dist[20],vist[20],a[20][20],n,i,j,k,min,pos,source;
clrscr();
printf("\nEnterthevalueofn");
scanf("%d",&n);
printf("\nEntertheadjacencymatrix");
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
scanf("%d",&a[i][j]);
}
}
printf("\nEnertthesourcenode");
scanf("%d",&source);
for(i=0;i<n;i++)
{
vist[i]=0;
dist[i]=a[source][i];
par[i]=source;

}
i=source;
for(j=0;j<n;j++)
{
vist[i]=1;
min=9999;
for(k=0;k<n;k++)
{
if(dist[i]+a[i][k]<dist[k])
{
dist[k]=dist[i]+a[i][k];
par[k]=i;
}
if(vist[k]==0&&dist[k]<min)
{
min=dist[k];
pos=k;
}
}
i=pos;
}
for(i=0;i<n;i++)
{
printf("\n");
display(par,source,i,i);
printf("%d",dist[i]);
}
getch();
}

8.Quicksort.
#include<stdio.h>
#include<conio.h>
#include<TIMER.H>
#include<alloc.h>
#include<stdlib.h>
intn;
intquick(inta[],intl,inth)

{
intpiv,temp,i,j;
if(l==h)
{
returnl;
}
piv=a[l];
i=l+1;
j=h;
while(i<=j)
{
for(;i<=h&&a[i]<=piv;i++);
for(;j>=(l+1)&&a[j]>=piv;j);
if(j==l)
{
returnl;
}
elseif(i==h+1)
{
a[l]=a[h];
a[h]=piv;
returnh;
}
elseif(i>j)
{
a[l]=a[j];
a[j]=piv;
return(j);
}
else
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
}
voidquicksort(inta[],intst,intend)
{

intpos;
if(st<end)
{
pos=quick(a,st,end);
quicksort(a,st,pos1);
quicksort(a,pos+1,end);
}
}
voidmain()
{
int*a,i;
Timert;
clrscr();
printf("\nEnterthevalueofn");
scanf("%d",&n);
a=(int*)malloc(n);
randomize();
for(i=0;i<n;i++)
{
a[i]=rand();
}
t.start();
quicksort(a,0,n1);
t.stop();
for(i=0;i<n1;i++)
{
if(a[i]>a[i+1])
{
printf("%d%d",a[i],i);
}
}
printf("\nTimetaken=%lf",t.time());
getch();
}

9.Kruskal'salgorithm.
#include<stdio.h>
#include<conio.h>

voidmain()
{
inta[20][20],b[20][20],c[20][20],d[20][20],nod=0,n,val1=0,i,j,k,t,m=0,posx,posy,val;
clrscr();
printf("\nEnterthevalueofn");
scanf("%d",&n);
printf("\nEntertheadjacencymatrix");
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
scanf("%d",&a[i][j]);
b[i][j]=(i==j?0:a[i][j]);
m=m+(b[i][j]?1:0);
c[i][j]=0;
d[i][j]=0;
}
}
for(m=m/2;m!=0&&(nod!=(n1));m)
{
val=32767;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(b[i][j]!=0&&b[i][j]<val)
{
posx=i;
posy=j;
val=b[i][j];
}
}
}
b[posx][posy]=0;
b[posy][posx]=0;
if(c[posx][posy]==0)
{
c[posx][posy]=1;
c[posy][posx]=1;

for(k=0;k<n;k++)
{
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
c[i][j]=c[i][j]|(c[i][k]&c[k][j]);
}
}
}
val1=val1+a[posx][posy];
nod=nod+1;
d[posx][posy]=a[posx][posy];
d[posy][posx]=a[posy][posx];
}
}
if(nod==n1)
{
for(i=0;i<n;i++)
{
printf("\n");
for(j=0;j<n;j++)
{
printf("%d",d[i][j]);
}
}
printf("\nSpanningtreehasacostof%d",val1);
}
else
{
printf("\nSpanningtreedoesnotexist!!");
}
getch();
}

10a.BFS.
#include<stdio.h>
#include<conio.h>

voidmain()
{
intq[20],a[20][20],r[20],st=0,ed=0,start,n,i,j;
clrscr();
printf("\nEnterthevalueofn");
scanf("%d",&n);
printf("\nEntertheadjacencymatrix");
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
scanf("%d",&a[i][j]);
r[i]=0;
}
}
printf("\nEnterthestartnode");
scanf("%d",&start);
q[ed++]=start1;
r[start1]=1;
printf("\nNodesreachablefromtheorigin(%d)are%d",start,start);
while(st!=ed)
{
for(i=0;i<n;i++)
{
if((r[i]==0)&&a[q[st]][i]==1)
{
q[ed++]=i;
r[i]=1;
printf("%d",i+1);
}
}
st++;
}
if(ed!=n)
{
printf("\nAllnodesarenotreachablefromorigin!!");
}
getch();
}

10b.DFS.
#include<stdio.h>
#include<conio.h>
voidmain()
{
inta[20][20],n,i,j,st[20],tot=1,top=1,r[20],flag;
clrscr();
printf("\nEnterthevalueofn");
scanf("%d",&n);
printf("\nEntertheadjacencymatrix");
for(i=0;i<n;i++)
{
r[i]=0;
for(j=0;j<n;j++)
{
scanf("%d",&a[i][j]);
}
}
st[++top]=0;
r[0]=1;
while(top!=1)
{
flag=0;
for(j=0;j<n;j++)
{
if(r[j]==0&&a[st[top]][j]==1)
{
st[++top]=j;
tot++;
r[j]=1;
flag=1;
break;
}
}
if(flag==0)
{
top=top1;

}
}
if(tot==n)
{
printf("\nAllnodesarereachablefromtheorigin!!");
}
else
{
printf("\nAllnodesarenotreachablefromtheorigin!!");
}
getch();
}

11.Subset.(backtrackingmethod1)
#include<stdio.h>
#include<conio.h>
voidmain()
{
ints[20],d,sum=0,n,x[20],top=0,i,tot=0;
clrscr();
printf("\nEnterthenumberofvalues");
scanf("%d",&n);
printf("\nEnterthevaluesinascendingorder");
for(i=0;i<n;i++)
{
scanf("%d",&s[i]);
}
printf("\nEnterthesum");
scanf("%d",&d);
x[top]=1;
printf("\nThesolutiontothesubsetproblemis");
while(top>=0)
{
x[top]=x[top]+1;
sum=sum+s[x[top]];
if(sum==d)
{
printf("\n");

tot=tot+1;
for(i=0;i<=top;i++)
{
printf("%d",s[x[i]]);
}
sum=sums[x[top]];
}
elseif(sum>d||top>=n)
{
sum=sums[x[top]];
if(top>=1)
{
sum=sums[x[top1]];
}
top=top1;
}
else
{
top=top+1;
x[top]=x[top1];
}
}
if(tot==0)
{
printf("notpossible");
}
getch();
}

11.Subset.(bruteforcemethod2supportsupto32inputsinthemainset)
#include<stdio.h>
#include<conio.h>
#include<math.h>
voidmain()
{
ints[20],x[20],n,sum,i,tot,soln=0;
longinta;
clrscr();

printf("\nEnterthevalueofn");
scanf("%d",&n);
printf("\nEnterthevalues");
for(i=0;i<n;i++)
{
scanf("%d",&s[i]);
}
printf("\nEnterthetotalsum");
scanf("%d",&tot);
printf("\nSolutiontotheproblemis");
for(a=0;a<pow(2,n);a=a+1)
{
sum=0;
for(i=0;i<n;i++)
{
if((a&(int)pow(2,i))!=0)
{
x[i]=1;
sum=sum+s[i];
}
else
{
x[i]=0;
}
}
if(sum==tot)
{
soln=soln+1;
printf("\n");
for(i=0;i<n;i++)
{
if(x[i]==1)
{
printf("%d",s[i]);
}
}
}
}
if(soln==0)

{
printf("isnotpossible!!");
}
getch();
}

12a.Horspool'sstringmatchingalgorithm.
#include<stdio.h>
#include<conio.h>
voidmain()
{
inti,j,tab[300],malen,salen;
charma[100],sa[100];
clrscr();
printf("\nEnterthemainarray");
fflush(stdin);
scanf("%[^\n]",ma);
printf("\nEnterthesubarray");
fflush(stdin);
scanf("%[^\n]",sa);
for(i=0;ma[i]!=0;i++);
malen=i;
for(i=0;i<sa[i]!=0;i++);
salen=i;
for(i=0;i<malen;i++)
{
tab[(int)ma[i]]=salen;
}
for(i=0;i<salen1;i++)
{
tab[(int)sa[i]]=saleni1;
}
i=salen1;
while(i<malen)
{
for(j=0;j<salen;j++)
{
if(sa[salen1j]!=ma[ij])

{
break;
}
}
if(j==salen)
{
printf("\nThesubstringisfoundatposition%dinthemainstring!!",i+2
salen);
break;
}
i=i+tab[(int)ma[i]];
}
if(j!=salen)
{
printf("\nSubstringnotfoundinthemainstring!!");
}
getch();
}

12b.Binomialcoefficientusingdynamicprogramming.
#include<stdio.h>
#include<conio.h>
longintbin(intn,intk)
{
inti,j;
longintarr[20][20];
for(i=0;i<=n;i++)
{
for(j=0;j<=(k<i?k:i);j++)
{
if(i==j||j==0)
{
arr[i][j]=1;
}
else
{
arr[i][j]=arr[i1][j]+arr[i1][j1];
}

}
}
return(arr[n][k]);
}
voidmain()
{
intn,k;
clrscr();
printf("\nEnterthevalueofn");
scanf("%d",&n);
printf("\nEnterthevalueofk");
scanf("%d",&k);
if(n<0||k<0||k>n)
{
printf("\nValuecannotbecalculated!!");
}
else
{
printf("\nThebinomialcoefficientis%ld.",bin(n,k));
}
getch();
}

13.Prim'salgorithm.
#include<stdio.h>
#include<conio.h>
voidmain()
{
inta[20][20],add[20],f[20][20],min,posx,posy,i,j,k,n,tot,flag=0,weight=0;
clrscr();
tot=0;
printf("\nEnterthevalueofn");
scanf("%d",&n);
printf("\nEntertheadjacencymatrix");
for(i=0;i<n;i++)
{
add[i]=0;
for(j=0;j<n;j++)

{
scanf("%d",&a[i][j]);
f[i][j]=0;
}
}
add[0]=1;
while(flag==0)
{
flag=1;
min=9999;
for(i=0;i<n;i++)
{
if(add[i]==1)
{
for(j=0;j<n;j++)
{
if(add[j]==0&&a[i][j]!=0&&a[i][j]<min)
{
min=a[i][j];
posx=i;
posy=j;
}
}
}
}
if(min!=9999)
{
f[posx][posy]=min;
f[posy][posx]=min;
weight=weight+f[posx][posy];
tot++;
flag=0;
add[posx]=1;
add[posy]=1;
}
}
if(tot!=n1)
{
printf("\nMinimumspannindoesnotexist!!");

}
else
{
printf("\nMinimumspanningtreewithweight=%dis",weight);
for(i=0;i<n;i++)
{
printf("\n");
for(j=0;j<n;j++)
{
printf("%d",f[i][j]);
}
}
}
getch();
}

14a.Warshall'salgorithm.
#include<stdio.h>
#include<conio.h>
voidmain()
{
intarr[20][20],i,j,k,n;
clrscr();
printf("\nEnterthenumberofnodes");
scanf("%d",&n);
printf("\nEntertheadjacencymatrix");
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
scanf("%d",&arr[i][j]);
}
}
for(k=0;k<n;k++)
{
for(j=0;j<n;j++)
{
for(i=0;i<n;i++)

{
arr[i][j]=arr[i][j]||(arr[i][k]&&arr[k][j]);
}
}
}
printf("\nThetransitiveclosureformedbyWarshallsalgorithmis");
for(i=0;i<n;i++)
{
printf("\n");
for(j=0;j<n;j++)
{
printf("%d",arr[i][j]);
}
}
getch();
}

15.nQueensproblem.
#include<stdio.h>
#include<conio.h>
#include<math.h>
voidmain()
{
intn,arr[20][20],i,j,k,tot=0,x[20],top;
charch;
clrscr();
printf("\nEnterthetotalnumberofqueens");
scanf("%d",&n);
top=0;
x[top]=1;
printf("\nThesolutiontothe%dqueensproblemis",n);
while(top>=0)
{
x[top]=x[top]+1;
while(x[top]<n)
{
for(i=0;i<top;i++)
{

if(x[i]==x[top]||(abs(x[top]x[i])==abs(topi)))
{
break;
}
}
if(i==top)
{
break;
}
x[top]=x[top]+1;
}
if(x[top]==n)
{
top=top1;
}
elseif(top==n1)
{
tot=tot+1;
ch=getch();
if(ch==0)
{
ch=getch();
}
printf("\n");
for(i=0;i<n;i++)
{
printf("\n");
for(j=0;j<n;j++)
{
if(x[i]==j)
{
printf("Q");
}
else
{
printf("X");
}
}
}

top=top1;
}
else
{
top=top+1;
x[top]=1;
}
}
if(tot==0)
{
printf("notpossible!!");
}
else
{
printf("\n\nThetotalnumberofsolutionsis%d.",tot);
}
getch();
}