MC9228

ALGORITHMS LAB

1. Quick Sort
2. Binary Search
3. Binary Tree Traversal
4. Warshalls Algorithm
5. Dijkstras Algorithm
6. Prims Algorithm
7. Knapsack Problem Dynamic Programming
8. Subset Sum Problem Backtracking
9. Travelling salesperson problem Branch and Bound
10. Strassens matrix multiplication

/* ============
QUICK SORT
============ */
#include<stdio.h>
#include<conio.h>
void main()
{
int a[10],i,n;
void quicksort(int [],int,int);
clrscr();
printf("\n\t\t\t QUICK SORT");
printf("\n\t\t\t ==========\n");
printf("\n\t\t ENTER THE NUMBER OF TERMS:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("\n\t\t ENTER %d VALUE:",i+1);
scanf("%d",&a[i]);
}
quicksort(a,0,n-1);
printf("\n\t\t THE SORTED ELEMENTS ARE AS FOLLOWS:");
for(i=0;i<n;i++)
printf("\n\n\t\t\t\t\t%d",a[i]);
getch();
}
int partition(int a[],int l,int r)
{
int p,i,j,temp;
p = a[l];
i = l;

j = r+1;
while(i<j)
{
do
{
i++;
}
while(a[i]<p);
do
{
j--;
}
while(a[j]>p);
if(i<j)
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
a[l] = a[j];
a[j] = p;
return(j);
}
void quicksort(int a[],int l,int r)
{
int s;
int partition(int [],int,int);
if(l>=r)
{
return;

}
s = partition(a,l,r);
quicksort(a,l,s-1);
quicksort(a,s+1,r);
}
OUTPUT:
QUICK SORT
==========
ENTER THE NUMBER OF TERMS:5
ENTER 1 VALUE:56
ENTER 2 VALUE:86
ENTER 3 VALUE:12
ENTER 4 VALUE:-1
ENTER 5 VALUE:0
THE SORTED ELEMENTS ARE AS FOLLOWS:
-1
0
12
56
86

/* ===============
BINARY SEARCH
=============== */
#include<stdio.h>
#include<conio.h>
void main()
{
int i,j,n,a[100],t,low,mid,high,x,s=0;
clrscr();
printf("\n\t\t\t BINARY SEARCH");
printf("\n\t\t\t =============\n");
printf("\n\t\t ENTER NUMBER OF TERMS:");
scanf("%d",&n);
printf("\n\t\t ENTER THE NUMBERS ONE BY ONE:");
for(i=0;i<n;i++)
{
scanf("%d",&a[i]);
}
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
if(a[i]>a[j])
{
t = a[i];
a[i] = a[j];
a[j] = t;
}
}
}
printf("\n\t\t THE SORTED ELEMENTS ARE:");
for(i=0;i<n;i++)

{
printf("\n\n\t\t\t\t %d",a[i]);
}
printf("\n\n\t\t ENTER THE ELEMENTS TO BE SEARCH:");
scanf("%d",&x);
low = 0;
high = n-1;
while(low <= high)
{
mid = (low+high) / 2;
if(x<a[mid])
high = mid-1;
else if(x>a[mid])
low = mid+1;
else if(x == a[mid])
{
s=1;
break;
}
}
if(s == 1)
{
printf("\n\n\t\t THE NUMBER %d IS FOUND IN THE",x);
printf(" POSITION %d",mid+1);
}
else
{
printf("\n\t\t THE NUMBER %d IS NOT FOUND",x);
}
getch();
}

OUTPUT:
BINARY SEARCH
==============
ENTER NUMBER OF TERMS:5
ENTER THE NUMBERS ONE BY ONE:56 34 89 31 22
THE SORTED ELEMENTS ARE:
22
31
34
56
89
ENTER THE ELEMENTS TO BE SEARCH:89
THE NUMBER 89 IS FOUND IN THE POSITION 5

BINARY SEARCH
==============
ENTER NUMBER OF TERMS:5
ENTER THE NUMBERS ONE BY ONE:56 34 89 31 22
THE SORTED ELEMENTS ARE:
22
31
34
56
89
ENTER THE ELEMENTS TO BE SEARCH:88
THE NUMBER 88 IS NOT FOUND

/* =======================
BINARY TREE TRAVERSAL
======================= */
#include<stdio.h>
#include<conio.h>
#define NULL 0
struct node
{
int info;
struct node *left,*right;
};
struct node *root;
struct node *maketree(int x)
{
struct node *p;
p = (struct node *) malloc (sizeof(struct node));
p->info = x;
p->left = NULL;
p->right = NULL;
return(p);
}
void setleft(struct node * p,int x)
{
p->left = maketree(x);
}
void setright(struct node * p,int x)
{
p->right = maketree(x);
}
void createtree(int x)
{

root = maketree(x);
}
void inserttree(int x)
{
struct node *p,*q;
q = root;
while(q!=NULL)
{
p=q;
if(x<p->info)
q = p->left;
else
q = p->right;
}
if(x<p->info)
setleft(p,x);
else
setright(p,x);
}
void preorder(struct node *p)
{
if(p!=NULL)
{
printf("\n\t\t\t\t %d",p->info);
preorder(p->left);
preorder(p->right);
}
}
void inorder(struct node *p)
{
if(p!=NULL)

{
inorder(p->left);
printf("\n\t\t\t\t %d",p->info);
inorder(p->right);
}
}
void postorder(struct node *p)
{
if(p!=NULL)
{
postorder(p->left);
postorder(p->right);
printf("\n\t\t\t\t %d",p->info);
}
}
void main()
{
int ch,x;
root = NULL;
clrscr();
printf("\n\t\t BINARY TREE TRAVERSAL");
printf("\n\t\t =====================\n");
printf("\n\t\t\t 1.CREATE");
printf("\n\t\t\t 2.INSERT");
printf("\n\t\t\t 3.PREORDER");
printf("\n\t\t\t 4.INORDER");
printf("\n\t\t\t 5.POSTORDER");
printf("\n\t\t\t 6.EXIT\n");
do
{
printf("\n\t\t ENTER YOUR CHOICE:");

scanf("%d",&ch);
switch(ch)
{
case 1:
if(root == NULL)
{
printf("\n\t\t ENTER THE DATA:");
scanf("%d",&x);
createtree(x);
}
else
printf("\n\t\t ALREADY CREATED");
break;
case 2:
printf("\n\t\t ENTER THE DATA TO BE INSERTED:");
scanf("%d",&x);
inserttree(x);
break;
case 3:
printf("\n\t\t\t PREORDER TRAVERSAL");
printf("\n\t\t\t ==================\n");
preorder(root);
break;
case 4:
printf("\n\t\t\t INORDER TRAVERSAL");
printf("\n\t\t\t =================\n");
inorder(root);
break;
case 5:
printf("\n\t\t\t POSTORDER TRAVERSAL");
printf("\n\t\t\t ===================\n");

postorder(root);
break;
case 6:
exit(0);
break;
}
}while(ch!=6);
getch();
}

OUTPUT:
BINARY TREE TRAVERSAL
**************************
1.CREATE
2.INSERT
3.PREORDER
4.INORDER
5.POSTORDER
6.EXIT

ENTER YOUR CHOICE:1

ENTER THE DATA:45
ENTER YOUR CHOICE:2
ENTER THE DATA TO BE INSERTED:88
ENTER YOUR CHOICE:2
ENTER THE DATA TO BE INSERTED:34
ENTER YOUR CHOICE:2
ENTER THE DATA TO BE INSERTED:56
ENTER YOUR CHOICE:3
PREORDER TRAVERSAL
====================
45
34
88
56
ENTER YOUR CHOICE:4

INORDER TRAVERSAL
===================
34
45
56
88
ENTER YOUR CHOICE:5
POSTORDER TRAVERSAL
=====================
34
56
88
45
ENTER YOUR CHOICE:6

/* =====================

WARSHALL'S ALGORITHM
====================== */
#include<stdio.h>
#include<conio.h>
void main()
{
int i,j,k,n,a[50][50],p[50][50],cflag;
clrscr();
printf("\n\t\t\t WARSHALL'S ALGORITHM");
printf("\n\t\t\t ====================\n");
printf("\n\t\t ENTER THE TOTAL NUMBER OF VERTICES:");
scanf("%d",&n);
printf("\n\t\t ENTER THE ADJACENCY MATRIX:");
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("\t");
scanf("%d",&a[i][j]);
p[i][j] = a[i][j];
}
}
for(k=0;k<n;k++)
{
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
p[i][j] = p[i][j] | p[i][k] & p[k][j];
}

}
}
cflag = 0;
printf("\n\t\t\t PATH MATRIX");
printf("\n\t\t\t ===========\n\n\t\t");
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("\t %d",p[i][j]);
if(p[i][j] == 1)
cflag = 1;
}
printf("\n\t\t");
}
if(cflag == 1)
printf("\n\t\t THERE IS A CYCLE IN THE GIVEN GRAPH");
getch();
}

OUTPUT:

WARSHALL'S ALGORITHM
=======================
ENTER THE TOTAL NUMBER OF VERTICES:4
ENTER THE ADJACENCY MATRIX: 0 1 0 0
0001
0000
1010
PATH MATRIX
============
1

THERE IS A CYCLE IN THE GIVEN GRAPH

/* ======================
DIJSKTRA'S ALGORITHM

====================== */
#include<stdio.h>
#include<conio.h>
int a[10][10];
void cgraph(int);
void fsp(int);
void disp(int);
int minvl(int[][10],int);
void main()
{
int n;
clrscr();
printf("\n\t\t\t DIJKSTRA'S ALGORITHM");
printf("\n\t\t\t ====================\n");
printf("\n\t\t ENTER THE NUMBER OF VERTICES:");
scanf("%d",&n);
printf("\n");
cgraph(n);
fsp(n);
disp(n);
getch();
}
void cgraph(int n)
{
int i,j;
for(i=1;i<=n;++i)
{
for(j=1;j<=n;++j)
{
if(i==j)

a[i][j]=0;
else
{
printf("\t\t IF PATH DOES NOT EXIT ENTER 1000:");
printf("\n\t\t ENTER THE COST FOR THE PATH %d --->%d:",i,j);
scanf("%d",&a[i][j]);
}
}
}
}
int minvl(int a[][10],int s)
{
int sml,i,j,pos;
sml = 9999;
for(i=2;i<=s;++i)
if(sml>a[1][i])
{
sml = a[1][i];
pos = i;
}
for(j=1;j<=s;++j)
a[i][j] = a[i][j+1];
return pos;
}
void fsp(int n)
{
int i,s,sml;
for(s=n;s>1;)
{
sml = minvl(a,s);

--s;
for(i=1;i<=n;++i)
{
if(i!=sml)
{
if(a[1][i]>(a[1][sml]+a[sml][i]))
a[1][i] = a[1][sml]+a[sml][i];
}
}
}
}
void disp(int n)
{
int i;
printf("\n\t\t\t SHORTEST PATH COST:");
printf("\n\t\t\t ===================");
for(i=1;i<=n;++i)
printf("\n\n\t\t\t PATH FROM 1 TO %d IS %d",i,a[1][i]);
}

OUTPUT:

DIJKSTRA'S ALGORITHM
=====================
ENTER THE NUMBER OF VERTICES:3
IF PATH DOES NOT EXIT ENTER 1000:
ENTER THE COST FOR THE PATH 1 --->2:6
IF PATH DOES NOT EXIT ENTER 1000:
ENTER THE COST FOR THE PATH 1 --->3:3
IF PATH DOES NOT EXIT ENTER 1000:
ENTER THE COST FOR THE PATH 2 --->1:1000
IF PATH DOES NOT EXIT ENTER 1000:
ENTER THE COST FOR THE PATH 2 --->3:4
IF PATH DOES NOT EXIT ENTER 1000:
ENTER THE COST FOR THE PATH 3 --->1:1000
IF PATH DOES NOT EXIT ENTER 1000:
ENTER THE COST FOR THE PATH 3 --->2:1000
SHORTEST PATH COST:
===================
PATH FROM 1 TO 1 IS 0
PATH FROM 1 TO 2 IS 6
PATH FROM 1 TO 3 IS 3

// PRIMS ALGORITHM

#include<stdio.h>
#include<conio.h>
void main()
{
int a[10][10],t[10][10],nearm[10];
int x,y,i,j,k,n,l;
int b,c,h,min,mincost;
clrscr();
printf("\n\t PRIM'S ALGORITHM");
printf("\n\t ****** *********");
printf("\n Enter the No.of Nodes:");
scanf("%d",&n);
printf("\n Enter the Cost Matrix");
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
printf("\n a[%d][%d]= ",i,j);
scanf("%d",&a[i][j]);
}
clrscr();
printf("\t\t PRIM'S ALGORITHMS USING GREEDY METHOD\n");
printf("\t\t =======================================\n\n");
printf("\n The Given Cost Matrix is :\n");
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
printf("%d\t",a[i][j]);
printf("\n");
}
min=999;

for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
if((i==j) || (a[i][j]==min))
continue;
else
if(a[i][j]<min)
{
min=a[i][j];
k=i;
l=j;
}
mincost=a[k][l];
t[1][1]=k;
t[1][2]=l;
for(i=1;i<=n;i++)
if(a[i][l]<a[i][k])
nearm[i]=l;
else
nearm[i]=k;
nearm[i]=k;
nearm[k]=0;
nearm[l]=0;
for(i=2;i<=n-1;i++)
{
min=999;
for(h=1;h<=n;h++)
{
x=nearm[h];
if((nearm[h]!=0)&&(a[h][x]<min))
{
j=h;

y=nearm[j];
min=a[h][y];
}
}
t[i][1]=j;
t[i][2]=nearm[j];
mincost=mincost+a[j][y];
nearm[j]=0;
for(k=1;k<=n;k++)
{
b=nearm[k];
if((nearm[k]!=0) && (a[k][b]>a[k][j]))
nearm[k]=j;
}
}
printf("\nThe Edges of Minimum Cost Spanning Tree");
for(i=1;i<n;i++)
{
b=t[i][1];
c=t[i][2];
printf("\n <%d> to <%d> = %d",b,c,a[b][c]);
}
printf("\nMinimum Cost Spanning Tree is %d",mincost);
getch();
}

OUTPUT:

PRIM'S ALGORITHM
****** *************
Enter the No.of Nodes:4
Enter the Cost Matrix
a[1][1]= 0
a[1][2]= 1
a[1][3]= 5
a[1][4]= 2
a[2][1]= 1
a[2][2]= 0
a[2][3]= 6
a[2][4]= 3
a[3][1]= 5
a[3][2]= 6
a[3][3]= 0
a[3][4]= 3
a[4][1]= 2
a[4][2]= 3
a[4][3]= 3
a[4][4]= 0

PRIM'S ALGORITHMS USING GREEDY METHOD

========================================

The Given Cost Matrix is :

0

The Edges of Minimum Cost Spanning Tree

<1> to <2> = 1
<4> to <1> = 2
<3> to <4> = 3
Minimum Cost Spanning Tree is 6

/* ===========================================

KNAPSACK PROBLEM - DYNAMIC PROGRAMMING

=========================================== */
#include<stdio.h>
#include<conio.h>
void main()
{
int i,j,n,w[10],v[10],cap,val[10][10];
clrscr();
printf("\n\t\t\t KNAPSACK PROBLEM");
printf("\n\t\t\t ================");
printf("\n\n\t\t ENTER THE NUMBER OF TERMS:");
scanf("%d",&n);
printf("\n\t\t ENTER THE WEIGHT OF THE ITEM:");
for(i=1;i<=n;i++)
{
scanf("%d",&w[i]);
}
printf("\n\t\t ENTER THE VALUE OF THE ITEM:");
for(i=1;i<=n;i++)
{
scanf("%d",&v[i]);
}
printf("\n\t\t ENTER THE CAPACITY:");
scanf("%d",&cap);
for(i=0;i<=n;i++)
{
for(j=0;j<=cap;j++)
{
if((i==0) || (j==0))
val[i][j] = 0;

else
if((j-w[i]) >=0)
if(val[i-1][j] > (v[i] + val[i-1][j-w[i]]))
val[i][j] = val[i-1][j];
else
val[i][j] = v[i] + val[i-1][j-w[i]];
else
val[i][j] = val[i-1][j];
}
}
printf("\n\t\t THE RESULT FOR KNAPSACK PROBLEM");
printf("\n\t\t ===============================\n\n\t\t");
for(i=0;i<=cap;i++)
printf("\t %d",i);
printf("\n");
for(i=0;i<=n;i++)
{
printf("\n\t");
printf("\t %d",i);
for(j=0;j<=cap;j++)
printf("\t %d",val[i][j]);
}
printf("\n\n\t\t THE VALUE IS %d",val[n][cap]);
getch();
}

OUTPUT:

KNAPSACK PROBLEM
===================
ENTER THE NUMBER OF TERMS: 4
ENTER THE WEIGHT OF THE ITEM: 2 1 3 2
ENTER THE VALUE OF THE ITEM: 12 10 20 15
ENTER THE CAPACITY:5
THE RESULT FOR KNAPSACK PROBLEM
===============================
0

12

12

12

12

10

12

22

22

22

10

12

22

30

32

10

15

25

30

37

THE VALUE IS 37

// SUM OF SUBSETS USING BACK-TRACKING METHODS

#include<stdio.h>
#include<conio.h>
int w[25];
// Sum Of Subset Function with Four Arguments
void sos(s,k,r,m)
{
int i;
static int x[25];
x[k]=1;
if(s+w[k]==m)
{
printf("\n\n\t THE SUBSET ");
printf(" { ");
for(i=1;i<=k;i++)
printf("%d ",x[i]);
printf(" } ");
}
else
if((s+w[k]+w[k+1])<=m)
{
sos(s+w[k],k+1,r-w[k],m);
}
if(((s+r-w[k])>=m)&&(s+w[k+1])<=m)
{
x[k]=0;
sos(s,k+1,r-w[k],m);
}
}
void main()
{

int i,j,sm,n,sum=0,r,max,temp;
clrscr();
printf("\n\t\t\t *-*-*-* SUM OF SUBSET *-*-*-* \n");
printf("\n\t ENTER THE NUMBER OF OBJECT : ");
scanf("%d",&n);
printf("\n\t ENTER THE WEIGHT OF THE OBJECT : ");
for(i=1;i<=n;i++)
{
scanf("%d",&w[i]);
sum +=w[i];
}
printf("\n\n ENTER THE WEIGHT OF THE FINDING OBJECTS : ");
scanf("%d",&sm);
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
if(w[i]<w[j])
{
temp=w[i];
w[i]=w[j];
w[j]=temp;
}
}
}
if(sm<w[i])
{
printf("\n\n SUMBSET CAN'T BE FOUND ");
}
else
{

printf("\n\n GIVEN SET : ");

printf(" { ");
for(i=1;i<=n;i++)
printf("%d ",w[i]);
printf(" } ");
printf("\n\n SUBSET FORMED WITH AS %d ",sm);
sos(0,1,sum,sm);
}
getch();
}

OUTPUT:

*-*-*-* SUM OF SUBSET *-*-*-*

ENTER THE NUMBER OF OBJECT : 5
ENTER THE WEIGHT OF THE OBJECT : 5 10 15 20 25
ENTER THE WEIGHT OF THE FINDING OBJECTS : 35
GIVEN SET : { 5 10 15 20 25 }
SUBSET FORMED WITH AS 35
THE SUBSET { 1 1 0 1 }
THE SUBSET { 0 1 0 0 1 }
THE SUBSET { 0 0 1 1 }

/* =================================
TRAVELLING SALES PERSON PROBLEM

================================= */
#include<stdio.h>
#include<conio.h>
#define inf 999
int cost[25][25];
int travel(int v,int t[20],int x,int path[10])
{
int a[25],temp[25],i,j,k,y,min = inf;
for(i=0;i<x;i++)
a[i] =0;
if(x == 1)
{
path[0] = t[0];
path[1] = 0;
return(cost[v][t[0]]+cost[t[0]][0]);
}
else
{
for(i=0;i<x;i++)
{
k = 0;
for(j=0;j<x;j++)
{
if(t[j] != t[i])
{
a[k] = t[j];
k++;
}
}
y = cost[v][t[i]]+travel(t[i],a,x-1,temp);

if(min>y)
{
path[0] = t[i];
k = 1;
min = y;
for(j=0;j<x;j++)
{
path[k] = temp[j];
k++;
}
}
}
}
return(min);
}
void main()
{
int num,i,j,min,a[20],sol[25],ch;
clrscr();
printf("\n\t\t TRAVELLING SALES PERSON PROBLEM");
printf("\n\t\t ===============================\n");
printf("\n\t\t ENTER THE NUMBER OF CITIES TO VISIT:");
scanf("%d",&num);
printf("\n\t\t 1.DIRECTED GRAPH");
printf("\t 2.UNDIRECTED GRAPH\n");
printf("\n\t\t SELECT THE TYPE OF GRAPH:");
scanf("%d",&ch);
printf("\n\t\t ENTER THE MAP:(ENTER 999 -> NO PATH)");
for(i=0;i<num;i++)
for(j=0;j<num;j++)

cost[i][j] = 0;
for(i=0;i<num;i++)
for(j=0;j<num;j++)
{
if(i == j)
cost[i][j] = inf;
if(cost[i][j] == 0)
{
printf("\n\t\t DISTANCE [ %d,%d] = ",i+1,j+1);
scanf("%d",&cost[i][j]);
if(ch == 2)
cost[j][i] = cost[i][j];
}
}
for(i=0;i<num-1;i++)
a[i] = i+1;
min = travel(0,&a[0],num-1,&sol[0]);
printf("\n\t\t\t PATH TO TRAVEL:");
printf("1");
for(i=0;i<num;i++)
printf("--->%d",sol[i]+1);
printf("\n\n\t\t MINIMUM DISTANCE TO TRAVEL");
printf(" TO THE CITIES %d",min);
getch();
}

OUTPUT:

TRAVELLING SALES PERSON PROBLEM

=================================
ENTER THE NUMBER OF CITIES TO VISIT:3
1.DIRECTED GRAPH

2.UNDIRECTED GRAPH

SELECT THE TYPE OF GRAPH:1

ENTER THE MAP:(ENTER 999 -> NO PATH)
DISTANCE [ 1,2] = 4
DISTANCE [ 1,3] = 5
DISTANCE [ 2,1] = 3
DISTANCE [ 2,3] = 6
DISTANCE [ 3,1] = 3
DISTANCE [ 3,2] = 7
PATH TO TRAVEL:1--->2--->3--->1
MINIMUM DISTANCE TO TRAVEL TO THE CITIES 13

/* ==================================
STRASSEN'S MATRIX MULTIPLICATION

================================== */
#include<stdio.h>
#include<conio.h>
void main()
{
int a[5][5],b[5][5],i,j,k,l,m1,m2,m3,m4,m5,m6,m7;
int c1,c2,c3,c4=0;
clrscr();
m1=m2=m3=m4=m5=m6=m7=0;
printf("\n\t\t STRASSEN'S MATRIX MULTIPLICATION");
printf("\n\t\t ================================\n");
printf("\n\t\t ENTER THE A MATRIX:");
for(i=0;i<2;i++)
{
for(j=0;j<2;j++)
{
scanf("%d",&a[i][j]);
}
}
printf("\n\t\t ENTER THE B MATRIX:");
for(i=0;i<2;i++)
{
for(j=0;j<2;j++)
{
scanf("%d",&b[i][j]);
}
}
printf("\n\t\t\t MATRIX A");
printf("\n\t\t\t ========");
for(i=0;i<2;i++)

{
printf("\n\t\t");
for(j=0;j<2;j++)
{
printf("\t[%d]",a[i][j]);
}
}
printf("\n");
printf("\n\t\t\t MATRIX B");
printf("\n\t\t\t ========");
for(i=0;i<2;i++)
{
printf("\n\t\t");
for(j=0;j<2;j++)
{
printf("\t[%d]",b[i][j]);
}
}
m1=(a[0][0]+a[1][1])*(b[0][0]+b[1][1]);
m2=(a[1][0]+a[1][1])*b[0][0];
m3=a[0][0]*(b[0][1]-b[1][1]);
m4=a[1][1]*(b[1][0]-b[0][0]);
m5=(a[0][0]+a[0][1])*b[1][1];
m6=(a[1][0]-a[0][0])*(b[0][0]+b[0][1]);
m7=(a[0][1]-a[1][1])*(b[1][0]+b[1][1]);
c1=m1+m4-m5+m7;
c2=m3+m5;
c3=m2+m4;
c4=m1+m3-m2+m6;
printf("\n");

printf("\n\t\t STRASSEN'S MATRIX MULTIPLICATON");

printf("\n\t\t ===============================\n");
printf("\n\t\t\t\t [%d]\t[%d]",c1,c2);
printf("\n\t\t\t\t [%d]\t[%d]",c3,c4);
getch();
}
OUTPUT:
STRASSEN'S MATRIX MULTIPLICATION
=================================
ENTER THE A MATRIX: 3 6
51
ENTER THE B MATRIX: 9 3
27
MATRIX A
========
[3]

[6]

[5]

[1]

MATRIX B
========
[9]

[3]

[2]

[7]

STRASSEN'S MATRIX MULTIPLICATON

=================================
[39] [51]
[47] [22]