# Maximum subsequence sum such that no three are consecutive

Last Updated : 05 Jul, 2023

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: 5We can't take three of them, so answer is2 + 3 = 5Input: arr[] = {3000, 2000, 1000, 3, 10}Output: 5013 3000 + 2000 + 3 + 10 = 5013Input: arr[] = {100, 1000, 100, 1000, 1}Output: 2101100 + 1000 + 1000 + 1 = 2101Input: arr[] = {1, 1, 1, 1, 1}Output: 4Input: arr[] = {1, 2, 3, 4, 5, 6, 7, 8}Output: 27`
Recommended Practice

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[0] = arr[0]// Note : All elements are positivesum[1] = arr[0] + arr[1]// We have three cases// 1) Exclude arr[2], i.e., sum[2] = sum[1]// 2) Exclude arr[1], i.e., sum[2] = sum[0] + arr[2]// 3) Exclude arr[0], i.e., sum[2] = arr[1] + arr[2] sum[2] = max(sum[1], arr[0] + arr[2], arr[1] + arr[2])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++ 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[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` `(``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[0]); ` `    ``cout << maxSumWO3Consec(arr, n); ` `    ``return` `0; ` `} `

## C

 `// C program to find the maximum sum such that` `// no three are consecutive` `#include `   `// Find maximum between two numbers.` `int` `max(``int` `num1, ``int` `num2)` `{` `    ``return` `(num1 > num2) ? num1 : num2;` `}`   `// 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[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` `(``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[0]);` `    ``printf``(``"%d \n"``, maxSumWO3Consec(arr, n));` `    ``return` `0;` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

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

## Python3

 `# 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[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()` `    ``{` `        ``int``[] arr = { 100, 1000, 100, 1000, 1 };` `        ``int` `n = arr.Length;` `        ``Console.Write(maxSumWO3Consec(arr, n));` `    ``}` `}`   `// This code is contributed by nitin mittal.`

## Javascript

 ``

## PHP

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

`1100`

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

Another approach: (Using recursion)

## Java

 `// C++ program to find the maximum sum such that` `// no three are consecutive using recursion.` `#include` `using namespace std;`   `// Returns maximum subsequence sum such that no three` `// elements are consecutive` `int` `maxSum(``int` `arr[], ``int` `i, vector<``int``> &dp)` `{` `    ``// base case` `    ``if` `(i < ``0``)` `        ``return` `0``;`   `    ``// this condition check is necessary to avoid segmentation fault at line 21` `    ``if` `(i == ``0``)` `        ``return` `arr[i];`   `    ``// returning maxSum for already processed indexes of array` `    ``if` `(dp[i] != -``1``)` `        ``return` `dp[i];`   `    ``// including current element and the next consecutive element in subsequence` `    ``int` `a = arr[i] + arr[i - ``1``] + maxSum(arr, i - ``3``, dp);`   `    ``// not including the current element in subsequence` `    ``int` `b = maxSum(arr, i - ``1``, dp);`   `    ``// including current element but skipping next consecutive element` `    ``int` `c = arr[i] + maxSum(arr, i - ``2``, dp);`   `    ``// returning the max of above 3 cases` `    ``return` `dp[i] = max(a, max(b, c));` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = {``100``, ``1000``, ``100``, ``1000``, ``1``};` `    ``int` `n = sizeof(arr) / sizeof(arr[``0``]);` `    ``vector<``int``> dp(n, -``1``);  ``// declaring and initializing dp vector` `    ``cout << maxSum(arr, n - ``1``, dp) << endl;`   `    ``return` `0``;` `}` `// This code is contributed by Ashish Kumar Yadav`

## 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(arr[n]+maxSumWO3Consec(n - ``1``),` `                    ``maxSumWO3Consec(n - ``3``) + arr[n]+arr[n-``1``]);` `    `  `    `  `} `   `// Driver code ` `public` `static` `void` `main(String[] args) ` `{` `    ``int` `n = arr.length; ` `        ``Arrays.fill(sum, -``1``);` `    ``System.out.println(maxSumWO3Consec(n-``1``));` `}` `}`   `// 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``-``1``] ``+` `arr[n ``-` `2``] ``+` `                     ``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``[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; ` `        ``for``(``int` `i = 0; i < sum.Length; i++)` `            ``sum[i] = -1;` `        ``Console.WriteLine(maxSumWO3Consec(n)); ` `    ``} ` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

## PHP

 ``

Output:

`2101`

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

Share your thoughts in the comments