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.

Asked in: Tolexo

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 <bits/stdc++.h>
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

<?php
// PHP 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
function FindMaxProduct( $arr, $n)
{
    $max = 0; $result;

    // iterate the rows.
    for ( $i = 0; $i < $n; $i++)
    {

        // iterate the columns.
        for ( $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 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

<script>

// Javascript program to find out the
// maximum product in the matrix
// which four elements are adjacent
// to each other in one direction
let n = 5;

    // function to find max product
    function FindMaxProduct(arr,n)
    {
        let max = 0, result;

        // iterate the rows.
        for (let i = 0; i < n; i++)
        {
            // iterate the columns.
            for (let 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 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}};*/

        let 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 ]];

        document.write(FindMaxProduct(arr, n));

// This code is contributed by sravan kumar

</script>

Output

3024

Time Complexity: O(n²)
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 <bits/stdc++.h>
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

<script>
// Javascript implementation of the above approach

    function maxPro(a,n,m,k)
    {
        let maxi = 1, mp = 1;
        for (let i = 0; i < n; ++i)
        {
            // Window Product for each row.
            let wp = 1;
            for (let l = 0; l < k; ++l)
            {
                wp *= a[i][l];
            }

            // Maximum window product for each row
            mp = wp;
            for (let 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
    let n = 6, m = 5, k = 4;
    let 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
    let maxpro = maxPro(a, n, m, k);
    document.write(maxpro);

    // This code is contributed by rag2127
</script>

Output

3024

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