Related Articles
Maximum subsequence sum such that no three are consecutive
• Difficulty Level : Medium
• Last Updated : 26 Mar, 2021

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

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

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

## Javascript

 ``

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]),``                    ``arr[n] + 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]),``                    ``arr[n] + 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]),``                     ``arr[n] ``+` `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]),``                        ``arr[n] + 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.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

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