Algorithm:

Step 1 :

Function to Add Matrices (add):

Iterate through each element of matrices A and B.

Add corresponding elements and store the result in the corresponding element of matrix C.

Step 2:

Function to Subtract Matrices (subtract):

Iterate through each element of matrices A and B.

Subtract corresponding elements and store the result in the corresponding element of matrix C.

Step 3

Function to Multiply Matrices (strassen):

If the size of the matrices is 1x1, perform a simple multiplication and store the result in the
corresponding element of matrix C.

Otherwise, perform the following steps for each quadrant of the matrices:

Split matrices A and B into four quadrants.

Compute seven products (P1 to P7) using recursive calls to strassen and specific additions and
subtractions.

Use the products to compute four quadrants of the resulting matrix C.

The recursive calls continue until matrices of size 1x1 are reached.

Step 4:

Function to Print a Matrix (printMatrix):

Iterate through each element of the matrix and print its value.

Print a newline after each row.

Step 5:

main Function:

Define the size of the matrices (n).

Initialize example matrices A and B.

Create a matrix C to store the result.

Call the strassen function to perform matrix multiplication.

Print the original matrices (A and B) and the result matrix (C).

Code:

#include <stdio.h>

// Function to add two matrices

void add(int n, int A[n][n], int B[n][n], int C[n][n]) {

for (int i = 0; i < n; i++)

for (int j = 0; j < n; j++)

C[i][j] = A[i][j] + B[i][j];

// Function to subtract two matrices

void subtract(int n, int A[n][n], int B[n][n], int C[n][n]) {

for (int i = 0; i < n; i++)

for (int j = 0; j < n; j++)

C[i][j] = A[i][j] - B[i][j];

// Function to multiply two matrices using Strassen's algorithm

void strassen(int n, int A[n][n], int B[n][n], int C[n][n]) {

if (n == 1) {

C[0][0] = A[0][0] * B[0][0];

return;

// Split matrices into quadrants

int newSize = n / 2;
 int A11[newSize][newSize], A12[newSize][newSize], A21[newSize][newSize], A22[newSize]
[newSize];

int B11[newSize][newSize], B12[newSize][newSize], B21[newSize][newSize], B22[newSize]

[newSize];

int C11[newSize][newSize], C12[newSize][newSize], C21[newSize][newSize], C22[newSize]

[newSize];

int P1[newSize][newSize], P2[newSize][newSize], P3[newSize][newSize], P4[newSize][newSize];

int P5[newSize][newSize], P6[newSize][newSize], P7[newSize][newSize];

int temp1[newSize][newSize], temp2[newSize][newSize];

// Partition input matrices

for (int i = 0; i < newSize; i++)

for (int j = 0; j < newSize; j++) {

A11[i][j] = A[i][j];

A12[i][j] = A[i][j + newSize];

A21[i][j] = A[i + newSize][j];

A22[i][j] = A[i + newSize][j + newSize];

B11[i][j] = B[i][j];

B12[i][j] = B[i][j + newSize];

B21[i][j] = B[i + newSize][j];

B22[i][j] = B[i + newSize][j + newSize];

// Compute products and subproducts

add(newSize, A11, A22, temp1);

add(newSize, B11, B22, temp2);

strassen(newSize, temp1, temp2, P1);

add(newSize, A21, A22, temp1);

strassen(newSize, temp1, B11, P2);

subtract(newSize, B12, B22, temp1);

strassen(newSize, A11, temp1, P3);

subtract(newSize, B21, B11, temp1);

strassen(newSize, A22, temp1, P4);

add(newSize, A11, A12, temp1);

strassen(newSize, temp1, B22, P5);

subtract(newSize, A21, A11, temp1);

add(newSize, B11, B12, temp2);

strassen(newSize, temp1, temp2, P6);

subtract(newSize, A12, A22, temp1);

add(newSize, B21, B22, temp2);

strassen(newSize, temp1, temp2, P7);

// Compute C11, C12, C21, C22

add(newSize, P1, P4, temp1);

subtract(newSize, temp1, P5, temp2);

add(newSize, temp2, P7, C11);

add(newSize, P3, P5, C12);

add(newSize, P2, P4, C21);

subtract(newSize, P1, P2, temp1);

add(newSize, temp1, P3, temp2);

add(newSize, temp2, P6, C22);

// Copy results back to C

for (int i = 0; i < newSize; i++)

 for (int j = 0; j < newSize; j++) {

C[i][j] = C11[i][j];

C[i][j + newSize] = C12[i][j];

C[i + newSize][j] = C21[i][j];

C[i + newSize][j + newSize] = C22[i][j];

// Function to print a matrix

void printMatrix(int n, int mat[n][n]) {

for (int i = 0; i < n; i++) {

for (int j = 0; j < n; j++)

printf("%d\t", mat[i][j]);

printf("\n");

int main() {

int n = 4; // Matrix size (should be a power of 2)

// Example matrices A and B

int A[4][4] = {

{1, 2, 3, 4},

{5, 6, 7, 8},

{9, 10, 11, 12},

{13, 14, 15, 16}

};

int B[4][4] = {

{17, 18, 19, 20},

{21, 22, 23, 24},

 {25, 26, 27, 28},

{29, 30, 31, 32}

};

// Resultant matrix C

int C[4][4];

// Perform matrix multiplication using Strassen's algorithm

strassen(n, A, B, C);

// Print the matrices

printf("Matrix A:\n");

printMatrix(n, A);

printf("\nMatrix B:\n");

printMatrix(n, B);

printf("\nMatrix C (Result of A * B using Strassen's algorithm):\n");

printMatrix(n, C);

return 0;

Output:

Matrix A:

1 2 3 4

5 6 7 8

9 10 11 12

13 14 15 16

Matrix B:
17 18 19 20

21 22 23 24

25 26 27 28

29 30 31 32

Matrix C (Result of A * B using Strassen's algorithm):

250 260 270 280

618 644 670 696

986 1028 1070 1112

1354 1412 1470 1528

Process returned 0 (0x0) execution time : 0.011 s