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


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 positive
sum[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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to find the maximum sum such that
// no three are consecutive
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to find the maximum
// sum such that no three are consecutive
  
// Returns maximum subsequence
// sum such that no three
// elements are consecutive
function 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 = array();
  
    // 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 = 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.
?>

chevron_right


Output :

2101

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

Another approach: (Using recursion)

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to find the maximum sum such that 
// no three are consecutive using recursion.
#include<bits/stdc++.h>
using namespace std;
  
int arr[] = {100, 1000, 100, 1000, 1};
int sum[10000];
  
// 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[0];
      
    if(n==2)
    return sum[n] = arr[1]+arr[0];
      
    // 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[0]);
    memset(sum,-1,sizeof(sum));
    cout << maxSumWO3Consec(n); 
  
// this code is contributed by Kushdeep Mittal
    return 0; 
}

chevron_right


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.



My Personal Notes arrow_drop_up