Algorithm Lab - MC9228

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);


inorder(p->right);

}

}

void postorder(struct node *p)

{

if(p!=NULL)

{

postorder(p->left);

postorder(p->right);


}

}

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 YOUR CHOICE:2


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);


}

}

}

}

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











SHORTEST PATH COST:

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

PATH FROM 1 TO 1 IS 0



// 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);


}

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++)

{


}

}

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]

Algorithm Lab - MC9228

Documents