Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Maximum sum such that no two elements are adjacent

  • Difficulty Level : Medium
  • Last Updated : 30 Nov, 2021

Given an array of positive numbers, find the maximum sum of a subsequence with the constraint that no 2 numbers in the sequence should be adjacent in the array. So 3 2 7 10 should return 13 (sum of 3 and 10) or 3 2 5 10 7 should return 15 (sum of 3, 5 and 7).Answer the question in most efficient way.

Examples : 

Become a success story instead of just reading about them. Prepare for coding interviews at Amazon and other top product-based companies with our Amazon Test Series. Includes topic-wise practice questions on all important DSA topics along with 10 practice contests of 2 hours each. Designed by industry experts that will surely help you practice and sharpen your programming skills. Wait no more, start your preparation today!

Input : arr[] = {5, 5, 10, 100, 10, 5}
Output : 110

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

Input : arr[] = {1, 20, 3}
Output : 20

Algorithm: 
Loop for all elements in arr[] and maintain two sums incl and excl where incl = Max sum including the previous element and excl = Max sum excluding the previous element.
Max sum excluding the current element will be max(incl, excl) and max sum including the current element will be excl + current element (Note that only excl is considered because elements cannot be adjacent).
At the end of the loop return max of incl and excl.

Example:  



  arr[] = {5,  5, 10, 40, 50, 35}

  incl = 5 
  excl = 0

  For i = 1 (current element is 5)
  incl =  (excl + arr[i])  = 5
  excl =  max(5, 0) = 5

  For i = 2 (current element is 10)
  incl =  (excl + arr[i]) = 15
  excl =  max(5, 5) = 5

  For i = 3 (current element is 40)
  incl = (excl + arr[i]) = 45
  excl = max(5, 15) = 15

  For i = 4 (current element is 50)
  incl = (excl + arr[i]) = 65
  excl =  max(45, 15) = 45

  For i = 5 (current element is 35)
  incl =  (excl + arr[i]) = 80
  excl =  max(65, 45) = 65

And 35 is the last element. So, answer is max(incl, excl) =  80

Thanks to Debanjan for providing code.

Implementation:  

C++




//c++ program for the above approach
#include <bits/stdc++.h>
 
using namespace std;
 
 
/*Function to return max sum such that no two elements
  are adjacent */
int FindMaxSum(vector<int> arr, int n)
{
    int incl = arr[0];
    int excl = 0;
    int excl_new;
    int i;
 
    for (i = 1; i < n; i++)
    {
        /* current max excluding i */
        excl_new = (incl > excl) ? incl : excl;
 
        /* current max including i */
        incl = excl + arr[i];
        excl = excl_new;
    }
 
    /* return max of incl and excl */
    return ((incl > excl) ? incl : excl);
}
 
// Driver program to test above functions
int main()
{
    vector<int> arr = {5, 5, 10, 100, 10, 5};
    cout<<FindMaxSum(arr, arr.size());
}
C



#include<stdio.h>
 
/*Function to return max sum such that no two elements
are adjacent */
int FindMaxSum(int arr[], int n)
{
int incl = arr[0];
int excl = 0;
int excl_new;
int i;
 
for (i = 1; i < n; i++)
{
    /* current max excluding i */
    excl_new = (incl > excl)? incl: excl;
 
    /* current max including i */
    incl = excl + arr[i];
    excl = excl_new;
}
 
/* return max of incl and excl */
return ((incl > excl)? incl : excl);
}
 
/* Driver program to test above function */
int main()
{
int arr[] = {5, 5, 10, 100, 10, 5};
int n = sizeof(arr) / sizeof(arr[0]);
printf("%d n", FindMaxSum(arr, n));
return 0;
}
Java



class MaximumSum
{
    /*Function to return max sum such that no two elements
      are adjacent */
    int FindMaxSum(int arr[], int n)
    {
        int incl = arr[0];
        int excl = 0;
        int excl_new;
        int i;
 
        for (i = 1; i < n; i++)
        {
            /* current max excluding i */
            excl_new = (incl > excl) ? incl : excl;
 
            /* current max including i */
            incl = excl + arr[i];
            excl = excl_new;
        }
 
        /* return max of incl and excl */
        return ((incl > excl) ? incl : excl);
    }
 
    // Driver program to test above functions
    public static void main(String[] args)
    {
        MaximumSum sum = new MaximumSum();
        int arr[] = new int[]{5, 5, 10, 100, 10, 5};
        System.out.println(sum.FindMaxSum(arr, arr.length));
    }
}
 
// This code has been contributed by Mayank Jaiswal
Python



# Function to return max sum such that
# no two elements are adjacent
def find_max_sum(arr):
    incl = 0
    excl = 0
    
    for i in arr:
         
        # Current max excluding i (No ternary in
        # Python)
        new_excl = excl if excl>incl else incl
        
        # Current max including i
        incl = excl + i
        excl = new_excl
     
    # return max of incl and excl
    return (excl if excl>incl else incl)
 
# Driver program to test above function
arr = [5, 5, 10, 100, 10, 5]
print find_max_sum(arr)
 
# This code is contributed by Kalai Selvan
C#



/* Program to return max sum such that no
two elements are adjacent */
using System;
 
class GFG {
     
    /* Function to return max sum such
    that no two elements are adjacent */
    static int FindMaxSum(int []arr, int n)
    {
        int incl = arr[0];
        int excl = 0;
        int excl_new;
        int i;
 
        for (i = 1; i < n; i++)
        {
            /* current max excluding i */
            excl_new = (incl > excl) ?
                            incl : excl;
 
            /* current max including i */
            incl = excl + arr[i];
            excl = excl_new;
        }
 
        /* return max of incl and excl */
        return ((incl > excl) ?
                            incl : excl);
    }
 
    // Driver program to test above
    // functions
    public static void Main()
    {
        int []arr = new int[]{5, 5, 10,
                              100, 10, 5};
                               
        Console.Write(
             FindMaxSum(arr, arr.Length));
    }
}
 
// This code has been contributed by
// nitin mittal
PHP



<?php
// PHP code to find Maximum sum
// such that no two elements
// are adjacent
 
/* Function to return max sum
   such that no two elements
   are adjacent */
function FindMaxSum($arr, $n)
{
    $incl = $arr[0];
    $excl = 0;
    $excl_new;
    $i;
 
for ($i = 1; $i <$n; $i++)
{
     
    // current max excluding i
    $excl_new = ($incl > $excl)? $incl: $excl;
 
    // current max including i
    $incl = $excl + $arr[$i];
    $excl = $excl_new;
}
 
// return max of incl and excl
return (($incl > $excl)? $incl : $excl);
}
 
// Driver Code
$arr = array(5, 5, 10, 100, 10, 5);
$n = sizeof($arr);
echo FindMaxSum($arr, $n);
     
// This code is contributed by Ajit
?>
Javascript



<script>
 
// Javascript program for the above approach
 
// Function to return max sum such that
// no two elements are adjacent
function FindMaxSum(arr, n)
{
    let incl = arr[0];
    let excl = 0;
    let excl_new;
    let i;
 
    for(i = 1; i < n; i++)
    {
         
        // Current max excluding i
        excl_new = (incl > excl) ? incl : excl;
 
        // Current max including i
        incl = excl + arr[i];
        excl = excl_new;
    }
 
    // Return max of incl and excl
    return ((incl > excl) ? incl : excl);
}
 
// Driver code
let arr = [ 5, 5, 10, 100, 10, 5 ];
 
document.write(FindMaxSum(arr, arr.length));
 
// This code is contributed by Mayank Tyagi
 
</script>
Output: 
110
Time Complexity: O(n)
This Problem can also be solved using Dynamic Programming 
Time Complexity : O(N)
Space Complexity:O(N)
C++



#include<bits/stdc++.h>
 
using namespace std;
 
 
 
int FindMaxSum(vector<int>arr, int n)
    {
        vector<int>dp(n);
        if(n==1)
        {
            return arr[0];
        }
        else if(n==2)
        {
            return max(arr[0],arr[1]);
             
        }
        else if(n==3)
        {
            dp[0]=arr[0];
            dp[1]=arr[1];
            dp[2]=arr[2]+arr[0];
            return max(dp[2],dp[0]);
        }
        else
        {
            dp[0]=arr[0];
            dp[1]=arr[1];
            dp[2]=arr[2]+arr[0];
            for(int i=3;i<n;i++)
            {
                dp[i]=arr[i]+max(dp[i-2],dp[i-3]);
            }
            return max(dp[n-1],dp[n-2]);
             
        }
         
    }
 
// { Driver Code Starts.
int main()
{
    //taking total testcases
    int t;
    cin>>t;
 
        //taking number of houses
         vector<int> arr = {5, 5, 10, 100, 10, 5};
          int n=6;
         
         
         
        //calling function FindMaxSum()
        cout<<FindMaxSum(arr,n)<<endl;
     
    return 0;
}
  // } Driver Code Ends
Refer Find maximum possible stolen value from houses for more explanation.
Now try the same problem for an array with negative numbers also.
Please write comments if you find any bug in the above program/algorithm or other ways to solve the same problem.
 



My Personal Notes
arrow_drop_up
Previous
Maximum sum such that no two elements are adjacent | Set 2
Next

Find maximum possible stolen value from houses
Recommended Articles
Page :
Maximum sum such that exactly half of the elements are selected and no two adjacent
27, Apr 20
Maximum sum in circular array such that no two elements are adjacent
21, Aug 18
Maximum sum in circular array such that no two elements are adjacent | Set 2
08, May 20
Maximum sum in a 2 x n grid such that no two elements are adjacent
08, Jun 17
Maximum sub-sequence sum such that indices of any two adjacent elements differs at least by 3
26, Jun 19
Maximum sum such that no two elements are adjacent | Set 2
14, May 19
Arrange N elements in circular fashion such that all elements are strictly less than sum of adjacent elements
11, Jul 19
Maximum sum of nodes in Binary tree such that no two are adjacent | Dynamic Programming
28, Mar 19
Minimum elements to be removed such that sum of adjacent elements is always odd
07, Feb 19
Minimum elements to be removed such that sum of adjacent elements is always even
18, Feb 19
Ways to paint stairs with two colors such that two adjacent are not yellow
12, Nov 17
Maximum sum of Array formed by replacing each element with sum of adjacent elements
23, Apr 20
Maximum length subsequence such that adjacent elements in the subsequence have a common factor
11, Feb 19
Missing occurrences of a number in an array such that maximum absolute difference of adjacent elements is minimum
07, May 20
Smallest number that can replace all -1s in an array such that maximum absolute difference between any pair of adjacent elements is minimum
28, Jun 21
Maximum flips possible such that no pair of adjacent elements are both 1
19, Jan 21
Length of the longest increasing subsequence such that no two adjacent elements are coprime
03, Apr 19
Maximum sum in an array such that every element has exactly one adjacent element to it
23, May 19
Rearrange given Array such that each elements is not equal to mean of adjacent elements
17, Aug 21
Permutation of Array such that sum of adjacent elements are not divisible by 3
15, Jul 20
Maximize sum of given array by rearranging array such that the difference between adjacent elements is atmost 1
25, Oct 20
Minimum count of groups such that sum of adjacent elements is divisible by K in each group
05, Jul 21
Cost of rearranging the array such that no element exceeds the sum of its adjacent elements
31, Aug 20
Minimum subarray reversals required such that sum of all pairs of adjacent elements is odd
05, Nov 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!