# 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
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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++

 `// C++ implementation of the approach ` `#include ` `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; ` `} `

## Java

 `// 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 `

## Python3

 `# 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 `

## C#

 `// 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 `

## PHP

 ` `

Output:

```12
```

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.