Skip to content
Related Articles

Related Articles

Improve Article

Maximum product of 4 adjacent elements in matrix

  • Difficulty Level : Easy
  • Last Updated : 30 Jun, 2021

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

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

 

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :