# Maximum sum in a 2 x n grid such that no two elements are adjacent

Given a rectangular grid of dimension 2 x n. We need to find out the maximum sum such that no two chosen numbers are adjacent, vertically, diagonally, or horizontally.
Examples:

```Input: 1 4 5
2 0 0
Output: 7
If we start from 1 then we can add only 5 or 0.
So max_sum = 6 in this case.
If we select 2 then also we can add only 5 or 0.
So max_sum = 7 in this case.
If we select from 4 or 0  then there is no further
So, Max sum is 7.

Input: 1 2 3 4 5
6 7 8 9 10
Output: 24```
Recommended Practice

Approach:

This problem is an extension of Maximum sum such that no two elements are adjacent. The only thing to be changed is to take a maximum element of both rows of a particular column. We traverse column by column and maintain the maximum sum considering two cases.
1) An element of the current column is included. In this case, we take a maximum of two elements in the current column.
2) An element of the current column is excluded (or not included)
Below is the implementation of the above steps.

## C++

 `// C++ program to find maximum sum in a grid such that ` `// no two elements are adjacent. ` `#include ` `#define MAX 1000 ` `using` `namespace` `std; ` ` `  `// Function to find max sum without adjacent ` `int` `maxSum(``int` `grid[MAX], ``int` `n) ` `{ ` `    ``// Sum including maximum element of first column ` `    ``int` `incl = max(grid, grid); ` ` `  `    ``// Not including first column's element ` `    ``int` `excl = 0, excl_new; ` ` `  `    ``// Traverse for further elements ` `    ``for` `(``int` `i = 1; i

## C

 `// C program to find maximum sum in a grid such that ` `// no two elements are adjacent. ` `#include ` ` `  `#define MAX 1000 ` ` `  `// Function to find max sum without adjacent ` `int` `maxSum(``int` `grid[MAX], ``int` `n) ` `{ ` `  ``// Sum including maximum element of first column ` `  ``int` `max = grid; ` `  ``if``(max < grid) ` `    ``max = grid; ` `  ``int` `incl = max; ` ` `  `  ``// Not including first column's element ` `  ``int` `excl = 0, excl_new; ` ` `  `  ``// Traverse for further elements ` `  ``for` `(``int` `i = 1; i

## Java

 `// Java Code for Maximum sum in a 2 x n grid ` `// such that no two elements are adjacent ` `import` `java.util.*; ` ` `  `class` `GFG { ` `     `  `    ``// Function to find max sum without adjacent ` `    ``public` `static` `int` `maxSum(``int` `grid[][], ``int` `n) ` `    ``{ ` `        ``// Sum including maximum element of first ` `        ``// column ` `        ``int` `incl = Math.max(grid[``0``][``0``], grid[``1``][``0``]); ` `      `  `        ``// Not including first column's element ` `        ``int` `excl = ``0``, excl_new; ` `      `  `        ``// Traverse for further elements ` `        ``for` `(``int` `i = ``1``; i < n; i++ ) ` `        ``{ ` `            ``// Update max_sum on including or  ` `            ``// excluding of previous column ` `            ``excl_new = Math.max(excl, incl); ` `      `  `            ``// Include current column. Add maximum element ` `            ``// from both row of current column ` `            ``incl = excl + Math.max(grid[``0``][i], grid[``1``][i]); ` `      `  `            ``// If current column doesn't to be included ` `            ``excl = excl_new; ` `        ``} ` `      `  `        ``// Return maximum of excl and incl ` `        ``// As that will be the maximum sum ` `        ``return` `Math.max(excl, incl); ` `    ``} ` `     `  `    ``/* Driver program to test above function */` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `         ``int` `grid[][] = {{ ``1``, ``2``, ``3``, ``4``, ``5``}, ` `                         ``{ ``6``, ``7``, ``8``, ``9``, ``10``}}; ` ` `  `         ``int` `n = ``5``; ` `         ``System.out.println(maxSum(grid, n)); ` `    ``} ` `  ``} ` `// This code is contributed by Arnav Kr. Mandal. `

## Python3

 `# Python3 program to find maximum sum in a grid such that  ` `# no two elements are adjacent.  ` ` `  `# Function to find max sum without adjacent  ` `def` `maxSum(grid, n) : ` `     `  `    ``# Sum including maximum element of first column  ` `    ``incl ``=` `max``(grid[``0``][``0``], grid[``1``][``0``])  ` ` `  `    ``# Not including first column's element  ` `    ``excl ``=` `0`   ` `  `    ``# Traverse for further elements  ` `    ``for` `i ``in` `range``(``1``, n) : ` `         `  `        ``# Update max_sum on including or excluding  ` `        ``# of previous column  ` `        ``excl_new ``=` `max``(excl, incl) ` ` `  `        ``# Include current column. Add maximum element  ` `        ``# from both row of current column  ` `        ``incl ``=` `excl ``+` `max``(grid[``0``][i], grid[``1``][i])  ` ` `  `        ``# If current column doesn't to be included  ` `        ``excl ``=` `excl_new ` ` `  `    ``# Return maximum of excl and incl  ` `    ``# As that will be the maximum sum  ` `    ``return` `max``(excl, incl)  ` ` `  ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` `  `  `    ``grid ``=` `[ [ ``1``, ``2``, ``3``, ``4``, ``5``],  ` `             ``[ ``6``, ``7``, ``8``, ``9``, ``10``] ] ` `    ``n ``=` `5` `    ``print``(maxSum(grid, n)) ` ` `  `/``/` `This code ``is` `contributed by Ryuga `

## C#

 `// C# program Code for Maximum sum  ` `// in a 2 x n grid such that no two ` `// elements are adjacent  ` `using` `System;     ` ` `  `class` `GFG  ` `{ ` ` `  `// Function to find max sum  ` `// without adjacent  ` `public` `static` `int` `maxSum(``int` `[,]grid, ``int` `n)  ` `{  ` `    ``// Sum including maximum element  ` `    ``// of first column  ` `    ``int` `incl = Math.Max(grid[0, 0],  ` `                        ``grid[1, 0]);  ` ` `  `    ``// Not including first column's ` `    ``// element  ` `    ``int` `excl = 0, excl_new;  ` ` `  `    ``// Traverse for further elements  ` `    ``for` `(``int` `i = 1; i < n; i++ )  ` `    ``{  ` `        ``// Update max_sum on including or  ` `        ``// excluding of previous column  ` `        ``excl_new = Math.Max(excl, incl);  ` ` `  `        ``// Include current column. Add  ` `        ``// maximum element from both  ` `        ``// row of current column  ` `        ``incl = excl + Math.Max(grid[0, i],  ` `                               ``grid[1, i]);  ` ` `  `        ``// If current column doesn't ` `        ``// to be included  ` `        ``excl = excl_new;  ` `    ``}  ` ` `  `    ``// Return maximum of excl and incl  ` `    ``// As that will be the maximum sum  ` `    ``return` `Math.Max(excl, incl);  ` `}  ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args)  ` `{  ` `    ``int` `[,]grid = {{ 1, 2, 3, 4, 5},  ` `                   ``{ 6, 7, 8, 9, 10}};  ` ` `  `    ``int` `n = 5;  ` `    ``Console.Write(maxSum(grid, n));  ` `}  ` `}  ` ` `  `// This code is contributed  ` `// by PrinciRaj1992 `

## PHP

 ` `

## Javascript

 ``

Output:

`24`

Time Complexity: O(n) where n is number of elements in given array. As, we are using a loop to traverse N times so it will cost us O(N) time
Auxiliary Space: O(1), as we are not using any extra space.
If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.