Maximum sum of cocktail glass in a 2D matrix

Given a 2D matrix mat[][], the task is to find the maximum sum of a cocktail glass.

A Cocktail glass is made of 6 cells in the following form:
X   X
  X
X X X 

Examples:



Input: mat[][] = {
{1, 0, 4, 0, 0},
{0, 3, 0, 0, 0},
{1, 1, 1, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0}}
Output: 11
Below is the cocktail glass with
maximum sum:
1   4 
  3
1 1 1
                                                      
Input: mat[][] = {
{0, 3, 0, 6, 0},
{0, 1, 1, 0, 0},
{1, 1, 1, 0, 0},
{0, 0, 2, 0, 1},
{0, 2, 0, 1, 3}}
Output: 12

Approach: It is evident from the definition of cocktail glass that the number of rows and number of columns must be greater than or equal to 3. If we count the total number of cocktail glasses in a matrix, we can say that the count is equal to the count of the possible top left cells in a cocktail glass. The number of top-left cells in a cocktail glass is equal to (R – 2) * (C – 2). Therefore, in a matrix total number of cocktail glass is (R – 2) * (C – 2)

For mat[][] = {
{0, 3, 0, 6, 0},
{0, 1, 1, 0, 0},
{1, 1, 1, 0, 0},
{0, 0, 2, 0, 1},
{0, 2, 0, 1, 3}}
Possible cocktail glasses are:
0   0  3   6   0   0
  1      1       0 
1 1 1  1 1 0   1 0 0 

0   1  1   0  1   0
  1      1      0  
0 0 2  0 2 0  2 0 1 

1   1  1   0  1   0
  0      2      0
0 2 0  2 0 1  0 1 3

We consider all top left cells of cocktail glasses one by one. For every cell, we compute the sum of the cocktail glass formed by it. Finally, we return the maximum sum.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
const int R = 5;
const int C = 5;
  
// Function to return the maximum sum
// of a cocktail glass
int findMaxCock(int ar[R][C])
{
  
    // If no cocktail glass is possible
    if (R < 3 || C < 3)
        return -1;
  
    // Initialize max_sum with the mini
    int max_sum = INT_MIN;
  
    // Here loop runs (R-2)*(C-2) times considering
    // different top left cells of cocktail glasses
    for (int i = 0; i < R - 2; i++) {
        for (int j = 0; j < C - 2; j++) {
  
            // Considering mat[i][j] as the top left
            // cell of the cocktail glass
            int sum = (ar[i][j] + ar[i][j + 2])
                      + (ar[i + 1][j + 1])
                      + (ar[i + 2][j] + ar[i + 2][j + 1]
                         + ar[i + 2][j + 2]);
  
            // Update the max_sum
            max_sum = max(max_sum, sum);
        }
    }
    return max_sum;
}
  
// Driver code
int main()
{
    int ar[][C] = { { 0, 3, 0, 6, 0 },
                    { 0, 1, 1, 0, 0 },
                    { 1, 1, 1, 0, 0 },
                    { 0, 0, 2, 0, 1 },
                    { 0, 2, 0, 1, 3 } };
  
    cout << findMaxCock(ar);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
class GFG
{
      
static int R = 5;
static int C = 5;
  
// Function to return the maximum sum
// of a cocktail glass
static int findMaxCock(int ar[][])
{
  
    // If no cocktail glass is possible
    if (R < 3 || C < 3)
        return -1;
  
    // Initialize max_sum with the mini
    int max_sum = Integer.MIN_VALUE;
  
    // Here loop runs (R-2)*(C-2) times considering
    // different top left cells of cocktail glasses
    for (int i = 0; i < R - 2; i++) 
    {
        for (int j = 0; j < C - 2; j++) 
        {
  
            // Considering mat[i][j] as the top left
            // cell of the cocktail glass
            int sum = (ar[i][j] + ar[i][j + 2])
                    + (ar[i + 1][j + 1])
                    + (ar[i + 2][j] + ar[i + 2][j + 1]
                        + ar[i + 2][j + 2]);
  
            // Update the max_sum
            max_sum = Math.max(max_sum, sum);
        }
    }
    return max_sum;
}
  
// Driver code
public static void main (String[] args) 
{
  
    int ar[][] = { { 0, 3, 0, 6, 0 },
                    { 0, 1, 1, 0, 0 },
                    { 1, 1, 1, 0, 0 },
                    { 0, 0, 2, 0, 1 },
                    { 0, 2, 0, 1, 3 } };
  
    System.out.println(findMaxCock(ar));
}
}
  
// This code is contributed by mits

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 implementation of the approach
import sys
  
R = 5
C = 5
  
# Function to return the maximum sum
# of a cocktail glass
def findMaxCock(ar):
      
    # If no cocktail glass is possible
    if (R < 3 or C < 3):
        return -1
  
    # Initialize max_sum with the mini
    max_sum = -sys.maxsize - 1
  
    # Here loop runs (R-2)*(C-2) times considering
    # different top left cells of cocktail glasses
    for i in range(R - 2):
        for j in range(C - 2):
              
            # Considering mat[i][j] as the top left
            # cell of the cocktail glass
            sum = ((ar[i][j] + ar[i][j + 2]) + 
                   (ar[i + 1][j + 1]) + 
                   (ar[i + 2][j] + ar[i + 2][j + 1] + 
                    ar[i + 2][j + 2]))
  
            # Update the max_sum
            max_sum = max(max_sum, sum)
  
    return max_sum;
  
# Driver code
if __name__ == '__main__':
    ar = [[0, 3, 0, 6, 0], 
          [0, 1, 1, 0, 0],
          [1, 1, 1, 0, 0],
          [0, 0, 2, 0, 1],
          [0, 2, 0, 1, 3]]
  
    print(findMaxCock(ar))
  
# This code is contributed by
# Surendra_Gangwar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach 
using System;
  
class GFG 
      
    static int R = 5; 
    static int C = 5; 
      
    // Function to return the maximum sum 
    // of a cocktail glass 
    static int findMaxCock(int [,]ar) 
    
      
        // If no cocktail glass is possible 
        if (R < 3 || C < 3) 
            return -1; 
      
        // Initialize max_sum with the mini 
        int max_sum = int.MinValue; 
      
        // Here loop runs (R-2)*(C-2) times considering 
        // different top left cells of cocktail glasses 
        for (int i = 0; i < R - 2; i++) 
        
            for (int j = 0; j < C - 2; j++) 
            
      
                // Considering mat[i][j] as the top left 
                // cell of the cocktail glass 
                int sum = (ar[i,j] + ar[i,j + 2]) 
                        + (ar[i + 1,j + 1]) 
                        + (ar[i + 2,j] + ar[i + 2,j + 1] 
                            + ar[i + 2,j + 2]); 
      
                // Update the max_sum 
                max_sum = Math.Max(max_sum, sum); 
            
        
        return max_sum; 
    
      
    // Driver code 
    public static void Main () 
    
      
        int [,]ar = { { 0, 3, 0, 6, 0 }, 
                        { 0, 1, 1, 0, 0 }, 
                        { 1, 1, 1, 0, 0 }, 
                        { 0, 0, 2, 0, 1 }, 
                        { 0, 2, 0, 1, 3 } }; 
      
        Console.WriteLine(findMaxCock(ar)); 
    
  
// This code is contributed by Ryuga

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?PHP
// PHP implementation of the approach
$R = 5;
$C = 5;
  
// Function to return the maximum sum
// of a cocktail glass
function findMaxCock($ar)
{
    global $R, $C;
      
    // If no cocktail glass is possible
    if ($R < 3 || $C < 3)
        return -1;
  
    // Initialize max_sum with the mini
    $max_sum = PHP_INT_MIN;
  
    // Here loop runs (R-2)*(C-2) times considering
    // different top left cells of cocktail glasses
    for ($i = 0; $i < $R - 2; $i++) 
    {
        for ($j = 0; $j < $C - 2; $j++) 
        {
  
            // Considering mat[i][j] as the top left
            // cell of the cocktail glass
            $sum = ($ar[$i][$j] + $ar[$i][$j + 2]) + 
                   ($ar[$i + 1][$j + 1]) + 
                   ($ar[$i + 2][$j] + $ar[$i + 2][$j + 1] + 
                    $ar[$i + 2][$j + 2]);
  
            // Update the max_sum
            $max_sum = max($max_sum, $sum);
        }
    }
    return $max_sum;
}
  
// Driver code
$ar = array(array( 0, 3, 0, 6, 0 ),
            array( 0, 1, 1, 0, 0 ),
            array( 1, 1, 1, 0, 0 ),
            array( 0, 0, 2, 0, 1 ),
            array( 0, 2, 0, 1, 3 ));
  
echo(findMaxCock($ar));
  
// This code is contributed by Code_Mech
?>

chevron_right


Output:

12


My Personal Notes arrow_drop_up

Strategy Path planning and Destination matters in success No need to worry about in between temporary failures

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.