Maximum subsequence sum such that no three are consecutive

• Difficulty Level : Medium
• Last Updated : 28 May, 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 consecutiveint 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 codeint 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 consecutiveimport 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 = 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(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 consecutivedef 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 = 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 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 codearr = [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 consecutiveusing 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.#includeusing namespace std; int arr[] = {100, 1000, 100, 1000, 1};int sum; // Returns maximum subsequence sum such that no three// elements are consecutiveint 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 codeint 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; // Returns maximum subsequence// sum such that no three// elements are consecutivestatic 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 codepublic 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 consecutivedef 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        return sum[n]         if(n == 2) :        sum[n] = arr + arr        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 codeif __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



Javascript



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 write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.