GFG App
Open App
Browser
Continue

# Maximum product of 4 adjacent elements in matrix

Given a square matrix, find the maximum product of four adjacent elements of the matrix. The adjacent elements of the matrix can be top, down, left, right, diagonal, or anti-diagonal. The four or more numbers should be adjacent to each other.

Note: n should be greater than or equal to 4 i.e n >= 4

Examples :

Input : n = 4
{{6, 2, 3 4},
{5, 4, 3, 1},
{7, 4, 5, 6},
{8, 3, 1, 0}}
Output : 1680
Explanation:
Multiplication of 6 5 7 8 produces maximum result and all element are adjacent to each other in one direction

Input : n = 5
{{1, 2, 3, 4, 5},
{6, 7, 8, 9, 1},
{2, 3, 4, 5, 6},
{7, 8, 9, 1, 0},
{9, 6, 4, 2, 3}}
Output: 3024
Explanation: Multiplication of 6 7 8 9 produces maximum result and all elements are adjacent to each other in one direction.

Approach:

1. Group 4 elements that are adjacent to each other in each row and calculate their maximum result.
2. Group 4 elements that are adjacent to each other in each column and calculate their maximum results.
3. Group 4 elements that are adjacent to each other in diagonal and calculate their maximum results.
4. Group 4 elements that are adjacent to each other in anti-diagonal and calculate their maximum results.
5. Compare all calculated maximum results.

Below is the implementation of the above approach:

## C++

 `// C++ program to find out the maximum product` `// in the matrix which four elements are ` `// adjacent to each other in one direction` `#include ` `using` `namespace` `std;`   `const` `int` `n = 5;`   `// function to find max product` `int` `FindMaxProduct(``int` `arr[][n], ``int` `n)` `{` `    ``int` `max = 0, result;`   `    ``// iterate the rows.` `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``{`   `        ``// iterate the columns.` `        ``for` `(``int` `j = 0; j < n; j++) ` `        ``{`   `            ``// check the maximum product ` `            ``// in horizontal row.` `            ``if` `((j - 3) >= 0) ` `            ``{` `                ``result = arr[i][j] * arr[i][j - 1] *` `                    ``arr[i][j - 2] * arr[i][j - 3];` `                `  `                ``if` `(max < result)` `                    ``max = result;` `            ``}`   `            ``// check the maximum product ` `            ``// in vertical row.` `            ``if` `((i - 3) >= 0) ` `            ``{` `                ``result = arr[i][j] * arr[i - 1][j] *` `                    ``arr[i - 2][j] * arr[i - 3][j];` `                `  `                ``if` `(max < result)` `                    ``max = result;` `            ``}`   `            ``// check the maximum product in` `            ``// diagonal (going through down - right)` `            ``if` `((i - 3) >= 0 && (j - 3) >= 0) ` `            ``{` `                ``result = arr[i][j] * arr[i - 1][j - 1] *` `                    ``arr[i - 2][j - 2] * arr[i - 3][j - 3];` `                `  `                ``if` `(max < result)` `                    ``max = result;` `            ``}` `            `  `            ``// check the maximum product in` `            ``// diagonal (going through up - right)` `            ``if` `((i - 3) >= 0 && (j - 3) <= 0)` `            ``{` `                ``result = arr[i][j] * arr[i - 1][j + 1] *` `                    ``arr[i - 2][j + 2] * arr[i - 3][j + 3];` `    `  `                ``if` `(max < result)` `                    ``max = result;` `            ``}` `        ``}` `    ``}`   `    ``return` `max;` `}`   `// Driver code` `int` `main()` `{`   `    ``/* int arr[][4] = {{6, 2, 3, 4}, ` `                    ``{5, 4, 3, 1},` `                    ``{7, 4, 5, 6},` `                    ``{8, 3, 1, 0}};*/` `    ``/* int arr[][5] = {{1, 2, 1, 3, 4},` `                    ``{5, 6, 3, 9, 2},` `                    ``{7, 8, 8, 1, 2},` `                    ``{1, 0, 7, 9, 3},` `                    ``{3, 0, 8, 4, 9}};*/` `                        `  `    ``int` `arr[][5] = {{1, 2, 3, 4, 5},` `                    ``{6, 7, 8, 9, 1},` `                    ``{2, 3, 4, 5, 6},` `                    ``{7, 8, 9, 1, 0},` `                    ``{9, 6, 4, 2, 3}};`   `    ``cout << FindMaxProduct(arr, n);` `    ``return` `0;` `}`

## Java

 `// Java program to find out the` `// maximum product in the matrix` `// which four elements are adjacent` `// to each other in one direction` `class` `GFG {` `    ``static` `final` `int` `n = ``5``;`   `    ``// function to find max product` `    ``static` `int` `FindMaxProduct(``int` `arr[][], ``int` `n)` `    ``{` `        ``int` `max = ``0``, result;`   `        ``// iterate the rows.` `        ``for` `(``int` `i = ``0``; i < n; i++)` `        ``{` `            ``// iterate the columns.` `            ``for` `(``int` `j = ``0``; j < n; j++) ` `            ``{` `                ``// check the maximum product` `                ``// in horizontal row.` `                ``if` `((j - ``3``) >= ``0``) ` `                ``{` `                    ``result = arr[i][j] * arr[i][j - ``1``]` `                             ``* arr[i][j - ``2``]` `                             ``* arr[i][j - ``3``];` `                    ``if` `(max < result)` `                        ``max = result;` `                ``}`   `                ``// check the maximum product` `                ``// in vertical row.` `                ``if` `((i - ``3``) >= ``0``) ` `                ``{` `                    ``result = arr[i][j] * arr[i - ``1``][j]` `                             ``* arr[i - ``2``][j]` `                             ``* arr[i - ``3``][j];`   `                    ``if` `(max < result)` `                        ``max = result;` `                ``}`   `                ``// check the maximum product in` `                ``// diagonal (going through down - right)` `                ``if` `((i - ``3``) >= ``0` `&& (j - ``3``) >= ``0``)` `                ``{` `                    ``result = arr[i][j] * arr[i - ``1``][j - ``1``]` `                             ``* arr[i - ``2``][j - ``2``]` `                             ``* arr[i - ``3``][j - ``3``];`   `                    ``if` `(max < result)` `                        ``max = result;` `                ``}`   `                ``// check the maximum product in` `                ``// diagonal (going through up - right)` `                ``if` `((i - ``3``) >= ``0` `&& (j - ``3``) <= ``0``) ` `                ``{` `                    ``result = arr[i][j] * arr[i - ``1``][j + ``1``]` `                             ``* arr[i - ``2``][j + ``2``]` `                             ``* arr[i - ``3``][j + ``3``];`   `                    ``if` `(max < result)` `                        ``max = result;` `                ``}` `            ``}` `        ``}`   `        ``return` `max;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``/* int arr[][4] = {{6, 2, 3, 4},` `                           ``{5, 4, 3, 1},` `                           ``{7, 4, 5, 6},` `                           ``{8, 3, 1, 0}};*/` `        ``/* int arr[][5] = {{1, 2, 1, 3, 4},` `                           ``{5, 6, 3, 9, 2},` `                           ``{7, 8, 8, 1, 2},` `                           ``{1, 0, 7, 9, 3},` `                           ``{3, 0, 8, 4, 9}};*/`   `        ``int` `arr[][] = { { ``1``, ``2``, ``3``, ``4``, ``5` `},` `                        ``{ ``6``, ``7``, ``8``, ``9``, ``1` `},` `                        ``{ ``2``, ``3``, ``4``, ``5``, ``6` `},` `                        ``{ ``7``, ``8``, ``9``, ``1``, ``0` `},` `                        ``{ ``9``, ``6``, ``4``, ``2``, ``3` `} };`   `        ``System.out.print(FindMaxProduct(arr, n));` `    ``}` `}`   `// This code is contributed by Anant Agarwal.`

## Python3

 `# Python3 program to find out the maximum ` `# product in the matrix which four elements ` `# are adjacent to each other in one direction` `n ``=` `5`   `# function to find max product` `def` `FindMaxProduct(arr, n):`   `    ``max` `=` `0`   `    ``# iterate the rows.` `    ``for` `i ``in` `range``(n): `   `        ``# iterate the columns.` `        ``for` `j ``in` `range``( n): `   `            ``# check the maximum product ` `            ``# in horizontal row.` `            ``if` `((j ``-` `3``) >``=` `0``):` `                ``result ``=` `(arr[i][j] ``*` `arr[i][j ``-` `1``] ``*` `                          ``arr[i][j ``-` `2``] ``*` `arr[i][j ``-` `3``])` `                `  `                ``if` `(``max` `< result):` `                    ``max` `=` `result`   `            ``# check the maximum product ` `            ``# in vertical row.` `            ``if` `((i ``-` `3``) >``=` `0``) :` `                ``result ``=` `(arr[i][j] ``*` `arr[i ``-` `1``][j] ``*` `                          ``arr[i ``-` `2``][j] ``*` `arr[i ``-` `3``][j])` `                `  `                ``if` `(``max` `< result):` `                    ``max` `=` `result`   `            ``# check the maximum product in` `            ``# diagonal going through down - right ` `            ``if` `((i ``-` `3``) >``=` `0` `and` `(j ``-` `3``) >``=` `0``):` `                ``result ``=` `(arr[i][j] ``*` `arr[i ``-` `1``][j ``-` `1``] ``*` `                          ``arr[i ``-` `2``][j ``-` `2``] ``*` `arr[i ``-` `3``][j ``-` `3``])` `                `  `                ``if` `(``max` `< result):` `                    ``max` `=` `result`   `            ``# check the maximum product in` `            ``# diagonal going through up - right` `            ``if` `((i ``-` `3``) >``=` `0` `and` `(j ``-` `3``) <``=` `0``):` `                ``result ``=` `(arr[i][j] ``*` `arr[i ``-` `1``][j ``+` `1``] ``*` `                          ``arr[i ``-` `2``][j ``+` `2``] ``*` `arr[i ``-` `3``][j ``+` `3``])`   `                ``if` `(``max` `< result):` `                    ``max` `=` `result`   `    ``return` `max`   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:` `    `    `    ``# int arr[][4] = {{6, 2, 3, 4}, ` `    ``#                  {5, 4, 3, 1},` `    ``#                  {7, 4, 5, 6},` `    ``#                  {8, 3, 1, 0}};` `    ``# int arr[][5] = {{1, 2, 1, 3, 4},` `    ``#                  {5, 6, 3, 9, 2},` `    ``#                  {7, 8, 8, 1, 2},` `    ``#                  {1, 0, 7, 9, 3},` `    ``#                  {3, 0, 8, 4, 9}};` `                        `  `    ``arr ``=` `[[``1``, ``2``, ``3``, ``4``, ``5``],` `           ``[``6``, ``7``, ``8``, ``9``, ``1``],` `           ``[``2``, ``3``, ``4``, ``5``, ``6``],` `           ``[``7``, ``8``, ``9``, ``1``, ``0``],` `            ``[``9``, ``6``, ``4``, ``2``, ``3``]]`   `    ``print``(FindMaxProduct(arr, n))`   `# This code is contributed by ita_c`

## C#

 `// C# program to find out the` `// maximum product in the matrix` `// which four elements are adjacent` `// to each other in one direction` `using` `System;`   `public` `class` `GFG {`   `    ``static` `int` `n = 5;`   `    ``// Function to find max product` `    ``static` `int` `FindMaxProduct(``int``[, ] arr, ``int` `n)` `    ``{` `        ``int` `max = 0, result;`   `        ``// iterate the rows` `        ``for` `(``int` `i = 0; i < n; i++) {`   `            ``// iterate the columns` `            ``for` `(``int` `j = 0; j < n; j++) {`   `                ``// check the maximum product` `                ``// in horizontal row.` `                ``if` `((j - 3) >= 0) {`   `                    ``result = arr[i, j] * arr[i, j - 1]` `                             ``* arr[i, j - 2]` `                             ``* arr[i, j - 3];`   `                    ``if` `(max < result)` `                        ``max = result;` `                ``}`   `                ``// check the maximum product` `                ``// in vertical row.` `                ``if` `((i - 3) >= 0) {` `                    ``result = arr[i, j] * arr[i - 1, j]` `                             ``* arr[i - 2, j]` `                             ``* arr[i - 3, j];`   `                    ``if` `(max < result)` `                        ``max = result;` `                ``}`   `                ``// check the maximum product in` `                ``// diagonal going through down - right` `                ``if` `((i - 3) >= 0 && (j - 3) >= 0) {` `                    ``result = arr[i, j] * arr[i - 1, j - 1]` `                             ``* arr[i - 2, j - 2]` `                             ``* arr[i - 3, j - 3];`   `                    ``if` `(max < result)` `                        ``max = result;` `                ``}`   `                ``// check the maximum product in` `                ``// diagonal going through up - right` `                ``if` `((i - 3) >= 0 && (j - 3) <= 0) {` `                    ``result = arr[i, j] * arr[i - 1, j + 1]` `                             ``* arr[i - 2, j + 2]` `                             ``* arr[i - 3, j + 3];`   `                    ``if` `(max < result)` `                        ``max = result;` `                ``}` `            ``}` `        ``}`   `        ``return` `max;` `    ``}`   `    ``// Driver Code` `    ``static` `public` `void` `Main()` `    ``{` `        ``int``[, ] arr = { { 1, 2, 3, 4, 5 },` `                        ``{ 6, 7, 8, 9, 1 },` `                        ``{ 2, 3, 4, 5, 6 },` `                        ``{ 7, 8, 9, 1, 0 },` `                        ``{ 9, 6, 4, 2, 3 } };`   `        ``Console.Write(FindMaxProduct(arr, n));` `    ``}` `}`   `// This code is contributed by Shrikant13`

## PHP

 `= 0) ` `            ``{` `                ``\$result` `= ``\$arr``[``\$i``][``\$j``] * ` `                          ``\$arr``[``\$i``][``\$j` `- 1] *` `                          ``\$arr``[``\$i``][``\$j` `- 2] * ` `                          ``\$arr``[``\$i``][``\$j` `- 3];` `                `  `                ``if` `(``\$max` `< ``\$result``)` `                    ``\$max` `= ``\$result``;` `            ``}`   `            ``// check the maximum product ` `            ``// in vertical row.` `            ``if` `((``\$i` `- 3) >= 0) ` `            ``{` `                ``\$result` `= ``\$arr``[``\$i``][``\$j``] * ` `                          ``\$arr``[``\$i` `- 1][``\$j``] *` `                          ``\$arr``[``\$i` `- 2][``\$j``] * ` `                          ``\$arr``[``\$i` `- 3][``\$j``];` `                `  `                ``if` `(``\$max` `< ``\$result``)` `                    ``\$max` `= ``\$result``;` `            ``}`   `            ``// check the maximum product in` `            ``// diagonal going through down - right` `            ``if` `((``\$i` `- 3) >= 0 ``and` `(``\$j` `- 3) >= 0) ` `            ``{` `                ``\$result` `= ``\$arr``[``\$i``][``\$j``] * ` `                          ``\$arr``[``\$i` `- 1][``\$j` `- 1] *` `                          ``\$arr``[``\$i` `- 2][``\$j` `- 2] * ` `                          ``\$arr``[``\$i` `- 3][``\$j` `- 3];` `                `  `                ``if` `(``\$max` `< ``\$result``)` `                    ``\$max` `= ``\$result``;` `            ``}` `            `  `            ``// check the maximum product in` `            ``// diagonal going through up - right` `            ``if` `((``\$i` `- 3) >= 0 ``and` `(``\$j` `- 3) <= 0) ` `            ``{` `                ``\$result` `= ``\$arr``[``\$i``][``\$j``] * ` `                          ``\$arr``[``\$i` `- 1][``\$j` `+ 1] *` `                          ``\$arr``[``\$i` `- 2][``\$j` `+ 2] * ` `                          ``\$arr``[``\$i` `- 3][``\$j` `+ 3];` `                `  `                ``if` `(``\$max` `< ``\$result``)` `                    ``\$max` `= ``\$result``;` `            ``}` `            `  `        ``}` `    ``}`   `    ``return` `\$max``;` `}` `    `  `    ``// Driver Code                        ` `    ``\$arr` `= ``array``(``array``(1, 2, 3, 4, 5),` `                 ``array``(6, 7, 8, 9, 1),` `                 ``array``(2, 3, 4, 5, 6),` `                 ``array``(7, 8, 9, 1, 0),` `                 ``array``(9, 6, 4, 2, 3));` ` `  `    ``echo` `FindMaxProduct(``\$arr``, ``\$n``);`   `// This code is contributed by anuj_67.` `?>`

## Javascript

 ``

Output

`3024`

Time Complexity: O(n2)
Auxiliary Space: O(1), as no extra space is used

For row-wise adjacent elements, we can generalize the method using a sliding window.

Note: All elements in the matrix must be non-zero.

Another Approach:

1. For each row, create a window of size k. Find the product of k adjacent element as window product (wp).
2. Iterate through the row from k to  (row size), by sliding window approach, find the maximum product. Note: (row size)>=k.
3. Assign the maximum product to a global maximum product.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach` `#include ` `using` `namespace` `std;`   `int` `maxPro(``int` `a[6][5], ``int` `n, ``int` `m, ``int` `k)` `{` `    ``int` `maxi(1), mp(1);` `    ``for` `(``int` `i = 0; i < n; ++i) ` `    ``{` `        ``// Window Product for each row.` `        ``int` `wp(1); ` `        ``for` `(``int` `l = 0; l < k; ++l) ` `        ``{` `            ``wp *= a[i][l];` `        ``}` `      `  `        ``// Maximum window product for each row` `        ``mp = wp; ` `        ``for` `(``int` `j = k; j < m; ++j) ` `        ``{` `            ``wp = wp * a[i][j] / a[i][j - k];` `          `  `            ``// Global maximum window product` `            ``maxi = max(maxi,max(mp,wp)); ` `        ``}` `    ``}` `    ``return` `maxi;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `n = 6, m = 5, k = 4;` `    ``int` `a[6][5] = { { 1, 2, 3, 4, 5 }, ` `                    ``{ 6, 7, 8, 9, 1 },` `                    ``{ 2, 3, 4, 5, 6 }, ` `                    ``{ 7, 8, 9, 1, 0 },` `                    ``{ 9, 6, 4, 2, 3 }, ` `                   ``{ 1, 1, 2, 1, 1 } };`   `    ``cout << maxPro(a, n, m, k);` `    ``return` `0;` `}`

## Java

 `// Java implementation of the above approach` `import` `java.io.*;`   `class` `GFG {` `    ``public` `static` `int` `maxPro(``int``[][] a, ` `                             ``int` `n, ``int` `m, ` `                             ``int` `k)` `    ``{` `        ``int` `maxi = ``1``, mp = ``1``;` `        ``for` `(``int` `i = ``0``; i < n; ++i)` `        ``{` `            ``// Window Product for each row.` `            ``int` `wp = ``1``; ` `            ``for` `(``int` `l = ``0``; l < k; ++l) ` `            ``{` `                ``wp *= a[i][l];` `            ``}` `           `  `            ``// Maximum window product for each row` `            ``mp = wp; ` `            ``for` `(``int` `j = k; j < m; ++j) ` `            ``{` `                ``wp = wp * a[i][j] / a[i][j - k];` `              `  `                ``// Global maximum` `                ``// window product` `                ``maxi = Math.max(` `                    ``maxi,` `                    ``Math.max(mp, wp)); ` `            ``}` `        ``}` `        ``return` `maxi;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `       `  `        ``int` `n = ``6``, m = ``5``, k = ``4``;` `        ``int``[][] a = ``new` `int``[][] {` `            ``{ ``1``, ``2``, ``3``, ``4``, ``5` `}, { ``6``, ``7``, ``8``, ``9``, ``1` `},` `            ``{ ``2``, ``3``, ``4``, ``5``, ``6` `}, { ``7``, ``8``, ``9``, ``1``, ``0` `},` `            ``{ ``9``, ``6``, ``4``, ``2``, ``3` `}, { ``1``, ``1``, ``2``, ``1``, ``1` `}` `        ``};` `      `  `       `  `        ``// Function call` `        ``int` `maxpro = maxPro(a, n, m, k);` `        ``System.out.println(maxpro);` `    ``}` `}`

## Python3

 `# Python implementation of the above approach` `def` `maxPro(a,n,m,k):` `    ``maxi ``=` `1` `    ``mp ``=` `1`  `    ``for` `i ``in` `range``(n):` `        `  `        ``# Window Product for each row.` `        ``wp ``=` `1` `        `  `        ``for` `l ``in` `range``(k):` `            ``wp ``*``=` `a[i][l]` `            `  `        ``# Maximum window product for each row` `        ``mp ``=` `wp` `        `  `        ``for` `j ``in` `range``(k,m):` `            ``wp ``=` `wp ``*` `a[i][j] ``/` `a[i][j ``-` `k]` `            `  `            ``# Global maximum` `            ``# window product` `            ``maxi ``=` `max``(` `                    ``maxi,` `                    ``max``(mp, wp))` `    `  `    ``return` `maxi`   `# Driver Code` `n ``=` `6` `m ``=` `5` `k ``=` `4` `a``=``[[``1``, ``2``, ``3``, ``4``, ``5` `], [ ``6``, ``7``, ``8``, ``9``, ``1` `],` `            ``[ ``2``, ``3``, ``4``, ``5``, ``6` `], [ ``7``, ``8``, ``9``, ``1``, ``0` `],` `            ``[ ``9``, ``6``, ``4``, ``2``, ``3` `], [ ``1``, ``1``, ``2``, ``1``, ``1` `]]`   `# Function call` `maxpro ``=` `maxPro(a, n, m, k)` `print``(maxpro)`   `# This code is contributed by ab2127`

## C#

 `// C# implementation of the above approach` `using` `System;`   `class` `GFG{` `    `  `public` `static` `int` `maxPro(``int``[,] a, ``int` `n,` `                         ``int` `m, ``int` `k)` `{` `    ``int` `maxi = 1, mp = 1;` `    ``for``(``int` `i = 0; i < n; ++i)` `    ``{` `        `  `        ``// Window Product for each row.` `        ``int` `wp = 1; ` `        ``for``(``int` `l = 0; l < k; ++l) ` `        ``{` `            ``wp *= a[i, l];` `        ``}` `        `  `        ``// Maximum window product for each row` `        ``mp = wp; ` `        ``for``(``int` `j = k; j < m; ++j) ` `        ``{` `            ``wp = wp * a[i, j] / a[i, j - k];` `            `  `            ``// Global maximum` `            ``// window product` `            ``maxi = Math.Max(maxi,` `                   ``Math.Max(mp, wp)); ` `        ``}` `    ``}` `    ``return` `maxi;` `}`   `// Driver Code` `static` `public` `void` `Main()` `{` `    ``int` `n = 6, m = 5, k = 4;` `    ``int``[,] a = {{ 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 1 },` `                ``{ 2, 3, 4, 5, 6 }, { 7, 8, 9, 1, 0 },` `                ``{ 9, 6, 4, 2, 3 }, { 1, 1, 2, 1, 1 }};` `   `  `    ``// Function call` `    ``int` `maxpro = maxPro(a, n, m, k);` `    ``Console.WriteLine(maxpro);` `}` `}`   `// This code is contributed by avanitrachhadiya2155`

## Javascript

 ``

Output

`3024`

Time Complexity: O(n2)
Auxiliary Space: O(1), as no extra space is used

My Personal Notes arrow_drop_up