Skip to content
Related Articles

Related Articles

Maximum product of 4 adjacent elements in matrix

View Discussion
Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 27 Jul, 2022
View Discussion
Improve Article
Save Article

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 - 1) <= 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 - 1) <= 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 - 1) <= 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 - 1) <= 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 - 1) <= 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 - 1) <= 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(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 <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(n2)
Auxiliary Space: O(1), as no extra space is used


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!