# Maximum subsequence sum such that no three are consecutive

Given a sequence of positive numbers, find the maximum sum that can be formed which has no three consecutive elements present.

Examples :

```Input: arr[] = {1, 2, 3}
Output: 5
We can't take three of them, so answer is
2 + 3 = 5

Input: arr[] = {3000, 2000, 1000, 3, 10}
Output: 5013
3000 + 2000 + 3 + 10 = 5013

Input: arr[] = {100, 1000, 100, 1000, 1}
Output: 2101
100 + 1000 + 1000 + 1 = 2101

Input: arr[] = {1, 1, 1, 1, 1}
Output: 4

Input: arr[] = {1, 2, 3, 4, 5, 6, 7, 8}
Output: 27
```

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

This problem is mainly an extension of below problem.

Maximum sum such that no two elements are adjacent

We maintain an auxiliary array sum[] (of same size as input array) to find the result.

```sum[i] : Stores result for subarray arr[0..i], i.e.,
maximum possible sum in subarray arr[0..i]
such that no three elements are consecutive.

sum = arr

// Note : All elements are positive
sum = arr + arr

// We have three cases
// 1) Exclude arr, i.e., sum = sum
// 2) Exclude arr, i.e., sum = sum + arr
// 3) Exclude arr, i.e., sum = arr + arr
sum = max(sum, arr + arr, arr + arr)

In general,
// We have three cases
// 1) Exclude arr[i],  i.e.,  sum[i] = sum[i-1]
// 2) Exclude arr[i-1], i.e., sum[i] = sum[i-2] + arr[i]
// 3) Exclude arr[i-2], i.e., sum[i-3] + arr[i] + arr[i-1]
sum[i] = max(sum[i-1], sum[i-2] + arr[i],
sum[i-3] + arr[i] + arr[i-1])
```

Below is implementation of above idea.

## C/C++

 `// C++ program to find the maximum sum such that ` `// no three are consecutive ` `#include ` `using` `namespace` `std; ` ` `  `// Returns maximum subsequence sum such that no three ` `// elements are consecutive ` `int` `maxSumWO3Consec(``int` `arr[], ``int` `n) ` `{ ` `    ``// Stores result for subarray arr[0..i], i.e., ` `    ``// maximum possible sum in subarray arr[0..i] ` `    ``// such that no three elements are consecutive. ` `    ``int` `sum[n]; ` ` `  `    ``// Base cases (process first three elements) ` `    ``if` `(n >= 1) ` `        ``sum = arr; ` ` `  `    ``if` `(n >= 2) ` `        ``sum = arr + arr; ` ` `  `    ``if` `(n > 2) ` `        ``sum = max(sum, max(arr + arr, arr + arr)); ` ` `  `    ``// Process rest of the elements ` `    ``// We have three cases ` `    ``// 1) Exclude arr[i], i.e., sum[i] = sum[i-1] ` `    ``// 2) Exclude arr[i-1], i.e., sum[i] = sum[i-2] + arr[i] ` `    ``// 3) Exclude arr[i-2], i.e., sum[i-3] + arr[i] + arr[i-1] ` `    ``for` `(``int` `i = 3; i < n; i++) ` `        ``sum[i] = max(max(sum[i - 1], sum[i - 2] + arr[i]), ` `                     ``arr[i] + arr[i - 1] + sum[i - 3]); ` ` `  `    ``return` `sum[n - 1]; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 100, 1000 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``cout << maxSumWO3Consec(arr, n); ` `    ``return` `0; ` `} `

## Java

 `// java program to find the maximum sum ` `// such that no three are consecutive ` `import` `java.io.*; ` ` `  `class` `GFG { ` ` `  `    ``// Returns maximum subsequence sum such that no three ` `    ``// elements are consecutive ` `    ``static` `int` `maxSumWO3Consec(``int` `arr[], ``int` `n) ` `    ``{ ` `        ``// Stores result for subarray arr[0..i], i.e., ` `        ``// maximum possible sum in subarray arr[0..i] ` `        ``// such that no three elements are consecutive. ` `        ``int` `sum[] = ``new` `int``[n]; ` ` `  `        ``// Base cases (process first three elements) ` `        ``if` `(n >= ``1``) ` `            ``sum[``0``] = arr[``0``]; ` ` `  `        ``if` `(n >= ``2``) ` `            ``sum[``1``] = arr[``0``] + arr[``1``]; ` ` `  `        ``if` `(n > ``2``) ` `            ``sum[``2``] = Math.max(sum[``1``], Math.max(arr[``1``] + arr[``2``], arr[``0``] + arr[``2``])); ` ` `  `        ``// Process rest of the elements ` `        ``// We have three cases ` `        ``// 1) Exclude arr[i], i.e., sum[i] = sum[i-1] ` `        ``// 2) Exclude arr[i-1], i.e., sum[i] = sum[i-2] + arr[i] ` `        ``// 3) Exclude arr[i-2], i.e., sum[i-3] + arr[i] + arr[i-1] ` `        ``for` `(``int` `i = ``3``; i < n; i++) ` `            ``sum[i] = Math.max(Math.max(sum[i - ``1``], sum[i - ``2``] + arr[i]), ` `                              ``arr[i] + arr[i - ``1``] + sum[i - ``3``]); ` ` `  `        ``return` `sum[n - ``1``]; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `arr[] = { ``100``, ``1000``, ``100``, ``1000``, ``1` `}; ` `        ``int` `n = arr.length; ` `        ``System.out.println(maxSumWO3Consec(arr, n)); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m `

## Python

 `# Python program to find the maximum sum such that ` `# no three are consecutive ` ` `  `# Returns maximum subsequence sum such that no three ` `# elements are consecutive ` `def` `maxSumWO3Consec(arr, n): ` `    ``# Stores result for subarray arr[0..i], i.e., ` `    ``# maximum possible sum in subarray arr[0..i] ` `    ``# such that no three elements are consecutive. ` `    ``sum` `=` `[``0` `for` `k ``in` `range``(n)] ` ` `  `    ``# Base cases (process first three elements) ` `     `  `    ``if` `n >``=` `1` `: ` `        ``sum``[``0``] ``=` `arr[``0``] ` `     `  `    ``if` `n >``=` `2` `: ` `        ``sum``[``1``] ``=` `arr[``0``] ``+` `arr[``1``] ` `     `  `    ``if` `n > ``2` `: ` `        ``sum``[``2``] ``=` `max``(``sum``[``1``], ``max``(arr[``1``] ``+` `arr[``2``], arr[``0``] ``+` `arr[``2``])) ` ` `  `    ``# Process rest of the elements ` `    ``# We have three cases ` `    ``# 1) Exclude arr[i], i.e., sum[i] = sum[i-1] ` `    ``# 2) Exclude arr[i-1], i.e., sum[i] = sum[i-2] + arr[i] ` `    ``# 3) Exclude arr[i-2], i.e., sum[i-3] + arr[i] + arr[i-1] ` `    ``for` `i ``in` `range``(``3``, n): ` `        ``sum``[i] ``=` `max``(``max``(``sum``[i``-``1``], ``sum``[i``-``2``] ``+` `arr[i]), arr[i] ``+` `arr[i``-``1``] ``+` `sum``[i``-``3``]) ` ` `  `    ``return` `sum``[n``-``1``] ` ` `  `# Driver code ` `arr ``=` `[``100``, ``1000``, ``100``, ``1000``, ``1``] ` `n ``=` `len``(arr) ` `print` `maxSumWO3Consec(arr, n) ` ` `  `# This code is contributed by Afzal Ansari `

## C#

 `// C# program to find the maximum sum ` `// such that no three are consecutive ` `using` `System; ` `class` `GFG { ` ` `  `    ``// Returns maximum subsequence ` `    ``// sum such that no three ` `    ``// elements are consecutive ` `    ``static` `int` `maxSumWO3Consec(``int``[] arr, ` `                               ``int` `n) ` `    ``{ ` `        ``// Stores result for subarray ` `        ``// arr[0..i], i.e., maximum ` `        ``// possible sum in subarray ` `        ``// arr[0..i] such that no ` `        ``// three elements are consecutive. ` `        ``int``[] sum = ``new` `int``[n]; ` ` `  `        ``// Base cases (process ` `        ``// first three elements) ` `        ``if` `(n >= 1) ` `            ``sum = arr; ` ` `  `        ``if` `(n >= 2) ` `            ``sum = arr + arr; ` ` `  `        ``if` `(n > 2) ` `            ``sum = Math.Max(sum, Math.Max(arr + arr, arr + arr)); ` ` `  `        ``// Process rest of the elements ` `        ``// We have three cases ` `        ``// 1) Exclude arr[i], i.e., ` `        ``// sum[i] = sum[i-1] ` `        ``// 2) Exclude arr[i-1], i.e., ` `        ``// sum[i] = sum[i-2] + arr[i] ` `        ``// 3) Exclude arr[i-2], i.e., ` `        ``// sum[i-3] + arr[i] + arr[i-1] ` `        ``for` `(``int` `i = 3; i < n; i++) ` `            ``sum[i] = Math.Max(Math.Max(sum[i - 1], ` `                                       ``sum[i - 2] + arr[i]), ` `                              ``arr[i] + arr[i - 1] + sum[i - 3]); ` ` `  `        ``return` `sum[n - 1]; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int``[] arr = { 100, 1000, 100, 1000, 1 }; ` `        ``int` `n = arr.Length; ` `        ``Console.Write(maxSumWO3Consec(arr, n)); ` `    ``} ` `} ` ` `  `// This code is contributed by nitin mittal. `

## PHP

 `= 1) ` `    ``\$sum`` = ``\$arr``; ` `     `  `    ``if` `(``\$n` `>= 2) ` `    ``\$sum`` = ``\$arr`` + ``\$arr``; ` `     `  `    ``if` `( ``\$n` `> 2) ` `    ``\$sum`` = max(``\$sum``, max(``\$arr`` + ``\$arr``,  ` `                            ``\$arr`` + ``\$arr``)); ` ` `  `    ``// Process rest of the elements ` `    ``// We have three cases ` `    ``// 1) Exclude arr[i], i.e.,  ` `    ``// sum[i] = sum[i-1] ` `    ``// 2) Exclude arr[i-1], i.e.,  ` `    ``// sum[i] = sum[i-2] + arr[i] ` `    ``// 3) Exclude arr[i-2], i.e.,  ` `    ``// sum[i-3] + arr[i] + arr[i-1] ` `    ``for` `(``\$i` `= 3; ``\$i` `< ``\$n``; ``\$i``++) ` `        ``\$sum``[``\$i``] = max(max(``\$sum``[``\$i` `- 1],  ` `                        ``\$sum``[``\$i` `- 2] + ``\$arr``[``\$i``]),  ` `                        ``\$arr``[``\$i``] + ``\$arr``[``\$i` `- 1] +  ` `                                    ``\$sum``[``\$i` `- 3]); ` ` `  `    ``return` `\$sum``[``\$n``-1]; ` `} ` ` `  `// Driver code ` `\$arr` `= ``array``(100, 1000, 100, 1000, 1); ` `\$n` `=``count``(``\$arr``); ` `echo` `maxSumWO3Consec(``\$arr``, ``\$n``); ` ` `  `// This code is contributed by anuj_67. ` `?> `

Output :

```2101
```

Time Complexity : O(n)
Auxiliary Space : O(n)

Another approach: (Using recursion)

## C++

 `// C++ program to find the maximum sum such that  ` `// no three are consecutive using recursion. ` `#include ` `using` `namespace` `std; ` ` `  `int` `arr[] = {100, 1000, 100, 1000, 1}; ` `int` `sum; ` ` `  `// Returns maximum subsequence sum such that no three  ` `// elements are consecutive  ` `int` `maxSumWO3Consec(``int` `n) ` `{ ` `    ``if``(sum[n]!=-1) ` `    ``return` `sum[n]; ` `     `  `    ``//Base cases (process first three elements)  ` `     `  `    ``if``(n==0) ` `    ``return` `sum[n] = 0; ` `     `  `    ``if``(n==1) ` `    ``return` `sum[n] = arr; ` `     `  `    ``if``(n==2) ` `    ``return` `sum[n] = arr+arr; ` `     `  `    ``// Process rest of the elements  ` `    ``// We have three cases  ` `    ``return` `sum[n] = max(max(maxSumWO3Consec(n-1), ` `                    ``maxSumWO3Consec(n-2) + arr[n-1]),  ` `                    ``arr[n-2] + arr[n-1] + maxSumWO3Consec(n-3)); ` `     `  `     `  `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `     `  `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``memset``(sum,-1,``sizeof``(sum)); ` `    ``cout << maxSumWO3Consec(n);  ` ` `  `// this code is contributed by Kushdeep Mittal ` `    ``return` `0;  ` `} `

## Java

 `// Java program to find the maximum  ` `// sum such that no three are ` `// consecutive using recursion.  ` `import` `java.util.Arrays; ` ` `  `class` `GFG  ` `{ ` `     `  `static` `int` `arr[] = {``100``, ``1000``, ``100``, ``1000``, ``1``};  ` `static` `int` `sum[] = ``new` `int``[``10000``];  ` ` `  `// Returns maximum subsequence  ` `// sum such that no three  ` `// elements are consecutive  ` `static` `int` `maxSumWO3Consec(``int` `n)  ` `{  ` `    ``if``(sum[n] != -``1``)  ` `        ``return` `sum[n];  ` `     `  `    ``//Base cases (process first three elements)  ` `     `  `    ``if``(n == ``0``)  ` `        ``return` `sum[n] = ``0``;  ` `     `  `    ``if``(n == ``1``)  ` `        ``return` `sum[n] = arr[``0``];  ` `     `  `    ``if``(n == ``2``)  ` `        ``return` `sum[n] = arr[``1``] + arr[``0``];  ` `     `  `    ``// Process rest of the elements  ` `    ``// We have three cases  ` `    ``return` `sum[n] = Math.max(Math.max(maxSumWO3Consec(n - ``1``),  ` `                    ``maxSumWO3Consec(n - ``2``) + arr[n - ``1``]),  ` `                    ``arr[n - ``2``] + arr[n - ``1``] + maxSumWO3Consec(n - ``3``));  ` `     `  `     `  `}  ` ` `  `// Driver code  ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``int` `n = arr.length;  ` `        ``Arrays.fill(sum, -``1``); ` `    ``System.out.println(maxSumWO3Consec(n)); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## Python3

 `# Python3 program to find the maximum  ` `# sum such that no three are consecutive ` `# using recursion.  ` `arr ``=` `[``100``, ``1000``, ``100``, ``1000``, ``1``] ` `sum` `=` `[``-``1``] ``*` `10000` ` `  `# Returns maximum subsequence sum such  ` `# that no three elements are consecutive  ` `def` `maxSumWO3Consec(n) : ` ` `  `    ``if``(``sum``[n] !``=` `-``1``): ` `        ``return` `sum``[n] ` `     `  `    ``# 3 Base cases (process first  ` `    ``# three elements)  ` `    ``if``(n ``=``=` `0``) :  ` `        ``sum``[n] ``=` `0` `        ``return` `sum``[n] ` `     `  `    ``if``(n ``=``=` `1``) :  ` `        ``sum``[n] ``=` `arr[``0``] ` `        ``return` `sum``[n] ` `     `  `    ``if``(n ``=``=` `2``) :  ` `        ``sum``[n] ``=` `arr[``1``] ``+` `arr[``0``]  ` `        ``return` `sum``[n] ` `     `  `    ``# Process rest of the elements  ` `    ``# We have three cases  ` `    ``sum``[n] ``=` `max``(``max``(maxSumWO3Consec(n ``-` `1``),  ` `                     ``maxSumWO3Consec(n ``-` `2``) ``+` `arr[n ``-` `1``]),  ` `                     ``arr[n ``-` `2``] ``+` `arr[n ``-` `1``] ``+`  `                     ``maxSumWO3Consec(n ``-` `3``)) ` `     `  `    ``return` `sum``[n] ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `: ` ` `  `    ``n ``=` `len``(arr) ` `     `  `    ``print``(maxSumWO3Consec(n)) ` ` `  `# This code is contributed by Ryuga  `

## C#

 `// C# program to find the maximum  ` `// sum such that no three are  ` `// consecutive using recursion. ` `using` `System; ` ` `  `class` `GFG  ` `{  ` ` `  `    ``static` `int` `[]arr = {100, 1000, ` `                        ``100, 1000, 1};  ` `    ``static` `int` `[]sum = ``new` `int``;  ` ` `  `    ``// Returns maximum subsequence  ` `    ``// sum such that no three  ` `    ``// elements are consecutive  ` `    ``static` `int` `maxSumWO3Consec(``int` `n)  ` `    ``{  ` `        ``if``(sum[n] != -1)  ` `            ``return` `sum[n];  ` ` `  `        ``//Base cases (process first ` `        ``// three elements)  ` `        ``if``(n == 0)  ` `            ``return` `sum[n] = 0;  ` ` `  `        ``if``(n == 1)  ` `            ``return` `sum[n] = arr;  ` ` `  `        ``if``(n == 2)  ` `            ``return` `sum[n] = arr + arr;  ` ` `  `        ``// Process rest of the elements  ` `        ``// We have three cases  ` `        ``return` `sum[n] = Math.Max(Math.Max(maxSumWO3Consec(n - 1),  ` `                        ``maxSumWO3Consec(n - 2) + arr[n - 1]),  ` `                        ``arr[n - 2] + arr[n - 1] + maxSumWO3Consec(n - 3));  ` ` `  ` `  `    ``}  ` ` `  `    ``// Driver code  ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{  ` `        ``int` `n = arr.Length;  ` `        ``for``(``int` `i = 0; i < sum.Length; i++) ` `            ``sum[i] = -1; ` `        ``Console.WriteLine(maxSumWO3Consec(n));  ` `    ``}  ` `} ` ` `  `// This code is contributed by 29AjayKumar `

## PHP

 ` `

Output :

```2101
```

Time Complexity : O(n)
Auxiliary Space : O(n)

This article is contributed by Roshni Agarwal. 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.