Upload
subathra-devi-mourougane
View
12
Download
0
Embed Size (px)
DESCRIPTION
Algorithm Lab - MC9228
Citation preview
MC9228 ALGORITHMS LAB
1. Quick Sort
2. Binary Search
3. Binary Tree Traversal
4. Warshall’s Algorithm
5. Dijkstra’s Algorithm
6. Prim’s Algorithm
7. Knapsack Problem – Dynamic Programming
8. Subset Sum Problem – Backtracking
9. Travelling salesperson problem – Branch and Bound
10. Strassen’s 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
0 0 0 1
0 0 0 0
1 0 1 0
PATH MATRIX ============
1 1 1 1
1 1 1 1
0 0 0 0
1 1 1 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
// PRIM’S 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 1 5 2
1 0 6 3
5 6 0 3
2 3 3 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 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 12 12 12 12
2 0 10 12 22 22 22
3 0 10 12 22 30 32
4 0 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
5 1
ENTER THE B MATRIX: 9 3
2 7
MATRIX A
========
[3] [6]
[5] [1]
MATRIX B
========
[9] [3]
[2] [7]
STRASSEN'S MATRIX MULTIPLICATON
=================================
[39] [51]
[47] [22]