Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Maximum sum in circular array such that no two elements are adjacent

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

Given a circular array containing of positive integers value. The task is to find the maximum sum of a subsequence with the constraint that no 2 numbers in the sequence should be adjacent in the array.
Examples: 
 

Input: circular arr = {1, 2, 3, 1}
Output : 4
subsequence will be(1, 3), hence 1 + 3 = 4 

Input: circular arr = {1, 2, 3, 4, 5, 1}
Output: 9
subsequence will be(1, 3, 5), hence 1 + 3 + 5 = 9

 

Approach The problem can be solved using DP. An approach has already been discussed in this post, but it for an array. We can treat the circular subarray a two arrays one from (0th to n-2-th) and (1st to n-1-th) index, and use the approach used in the previous post. The maximum sum returned by both will be the answer. 
 

 

Below is the implementation of the above approach. 
 

C++




// CPP program to find maximum sum in a circular array
// such that no elements are adjacent in the sum.
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate the sum
// from 0th position to(n-2)th position
int maxSum1(int arr[], int n)
{
    int dp[n];
    int maxi = 0;
 
    for (int i = 0; i < n - 1; i++) {
 
        // copy the element of original array to dp[]
        dp[i] = arr[i];
 
        // find the maximum element in the array
        if (maxi < arr[i])
            maxi = arr[i];
    }
 
    // start from 2nd to n-1th pos
    for (int i = 2; i < n - 1; i++) {
 
        // traverse for all pairs
        // bottom-up approach
        for (int j = 0; j < i - 1; j++) {
 
            // dp-condition
            if (dp[i] < dp[j] + arr[i]) {
                dp[i] = dp[j] + arr[i];
 
                // find maximum sum
                if (maxi < dp[i])
                    maxi = dp[i];
            }
        }
    }
 
    // return the maximum
    return maxi;
}
 
// Function to find the maximum sum
// from 1st position to n-1-th position
int maxSum2(int arr[], int n)
{
    int dp[n];
    int maxi = 0;
 
    for (int i = 1; i < n; i++) {
        dp[i] = arr[i];
 
        if (maxi < arr[i])
            maxi = arr[i];
    }
 
    // Traverse from third to n-th pos
    for (int i = 3; i < n; i++) {
 
        // bottom-up approach
        for (int j = 1; j < i - 1; j++) {
 
            // dp condition
            if (dp[i] < arr[i] + dp[j]) {
                dp[i] = arr[i] + dp[j];
 
                // find max sum
                if (maxi < dp[i])
                    maxi = dp[i];
            }
        }
    }
 
    // return max
    return maxi;
}
 
int findMaxSum(int arr[], int n)
{
   return max(maxSum1(arr, n), maxSum2(arr, n));
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 2, 3, 1 };
    int n = sizeof(arr)/sizeof(arr[0]);
    cout << findMaxSum(arr, n);
    return 0;
}
Java



// Java  program to find maximum sum in a circular array
// such that no elements are adjacent in the sum.
 
import java.io.*;
 
class GFG {
     
     
// Function to calculate the sum
// from 0th position to(n-2)th position
static int maxSum1(int arr[], int n)
{
    int dp[]=new int[n];
    int maxi = 0;
 
    for (int i = 0; i < n - 1; i++) {
 
        // copy the element of original array to dp[]
        dp[i] = arr[i];
 
        // find the maximum element in the array
        if (maxi < arr[i])
            maxi = arr[i];
    }
 
    // start from 2nd to n-1th pos
    for (int i = 2; i < n - 1; i++) {
 
        // traverse for all pairs
        // bottom-up approach
        for (int j = 0; j < i - 1; j++) {
 
            // dp-condition
            if (dp[i] < dp[j] + arr[i]) {
                dp[i] = dp[j] + arr[i];
 
                // find maximum sum
                if (maxi < dp[i])
                    maxi = dp[i];
            }
        }
    }
 
    // return the maximum
    return maxi;
}
 
// Function to find the maximum sum
// from 1st position to n-1-th position
static int maxSum2(int arr[], int n)
{
    int dp[]=new int[n];
    int maxi = 0;
 
    for (int i = 1; i < n; i++) {
        dp[i] = arr[i];
 
        if (maxi < arr[i])
            maxi = arr[i];
    }
 
    // Traverse from third to n-th pos
    for (int i = 3; i < n; i++) {
 
        // bottom-up approach
        for (int j = 1; j < i - 1; j++) {
 
            // dp condition
            if (dp[i] < arr[i] + dp[j]) {
                dp[i] = arr[i] + dp[j];
 
                // find max sum
                if (maxi < dp[i])
                    maxi = dp[i];
            }
        }
    }
 
    // return max
    return maxi;
}
 
static int findMaxSum(int arr[], int n)
{
    int t=Math.max(maxSum1(arr, n), maxSum2(arr, n));
    return  t;
}
 
// Driver Code
    public static void main (String[] args) {
         
        int arr[] = { 1, 2, 3, 1 };
        int n = arr.length;
        System.out.println(findMaxSum(arr, n));
         
    }
}
Python 3



# Python 3 program to find maximum sum
# in a circular array such that no
# elements are adjacent in the sum.
 
# Function to calculate the sum from
# 0th position to(n-2)th position
def maxSum1(arr, n):
 
    dp = [0] * n
    maxi = 0
 
    for i in range(n - 1):
 
        # copy the element of original
        # array to dp[]
        dp[i] = arr[i]
 
        # find the maximum element in the array
        if (maxi < arr[i]):
            maxi = arr[i]
 
    # start from 2nd to n-1th pos
    for i in range(2, n - 1):
 
        # traverse for all pairs bottom-up
        # approach
        for j in range(i - 1) :
 
            # dp-condition
            if (dp[i] < dp[j] + arr[i]):
                dp[i] = dp[j] + arr[i]
 
                # find maximum sum
                if (maxi < dp[i]):
                    maxi = dp[i]
 
    # return the maximum
    return maxi
 
# Function to find the maximum sum
# from 1st position to n-1-th position
def maxSum2(arr, n):
 
    dp = [0] * n
    maxi = 0
 
    for i in range(1, n):
        dp[i] = arr[i]
 
        if (maxi < arr[i]):
            maxi = arr[i]
 
    # Traverse from third to n-th pos
    for i in range(3, n):
 
        # bottom-up approach
        for j in range(1, i - 1) :
 
            # dp condition
            if (dp[i] < arr[i] + dp[j]):
                dp[i] = arr[i] + dp[j]
 
                # find max sum
                if (maxi < dp[i]):
                    maxi = dp[i]
 
    # return max
    return maxi
 
def findMaxSum(arr, n):
    return max(maxSum1(arr, n), maxSum2(arr, n))
 
# Driver Code
if __name__ == "__main__":
     
    arr = [ 1, 2, 3, 1 ]
    n = len(arr)
    print(findMaxSum(arr, n))
 
# This code is contributed by ita_c
C#



// C# program to find maximum sum
// in a circular array such that
// no elements are adjacent in the sum.
using System;
 
class GFG
{
// Function to calculate the sum
// from 0th position to(n-2)th position
static int maxSum1(int []arr, int n)
{
    int []dp = new int[n];
    int maxi = 0;
 
    for (int i = 0; i < n - 1; i++)
    {
 
        // copy the element of original
        // array to dp[]
        dp[i] = arr[i];
 
        // find the maximum element
        // in the array
        if (maxi < arr[i])
            maxi = arr[i];
    }
 
    // start from 2nd to n-1th pos
    for (int i = 2; i < n - 1; i++)
    {
 
        // traverse for all pairs
        // bottom-up approach
        for (int j = 0; j < i - 1; j++)
        {
 
            // dp-condition
            if (dp[i] < dp[j] + arr[i])
            {
                dp[i] = dp[j] + arr[i];
 
                // find maximum sum
                if (maxi < dp[i])
                    maxi = dp[i];
            }
        }
    }
 
    // return the maximum
    return maxi;
}
 
// Function to find the maximum sum
// from 1st position to n-1-th position
static int maxSum2(int []arr, int n)
{
    int []dp = new int[n];
    int maxi = 0;
 
    for (int i = 1; i < n; i++)
    {
        dp[i] = arr[i];
 
        if (maxi < arr[i])
            maxi = arr[i];
    }
 
    // Traverse from third to n-th pos
    for (int i = 3; i < n; i++)
    {
 
        // bottom-up approach
        for (int j = 1; j < i - 1; j++)
        {
 
            // dp condition
            if (dp[i] < arr[i] + dp[j])
            {
                dp[i] = arr[i] + dp[j];
 
                // find max sum
                if (maxi < dp[i])
                    maxi = dp[i];
            }
        }
    }
 
    // return max
    return maxi;
}
 
static int findMaxSum(int []arr, int n)
{
    int t = Math.Max(maxSum1(arr, n),
                     maxSum2(arr, n));
    return t;
}
 
// Driver Code
static public void Main ()
{
    int []arr = { 1, 2, 3, 1 };
    int n = arr.Length;
    Console.WriteLine(findMaxSum(arr, n));
}
}
 
// This code is contributed
// by Sach_Code
PHP



<?php
// PHP program to find maximum sum in
// a circular array such that no
// elements are adjacent in the sum.
// Function to calculate the sum
// from 0th position to(n-2)th position
 
function maxSum1($arr, $n)
{
    $dp[$n] = array();
    $maxi = 0;
 
    for ($i = 0; $i < $n - 1; $i++)
    {
 
        // copy the element of original
        // array to dp[]
        $dp[$i] = $arr[$i];
 
        // find the maximum element in the array
        if ($maxi < $arr[$i])
            $maxi = $arr[$i];
    }
 
    // start from 2nd to n-1th pos
    for ($i = 2; $i < $n - 1; $i++)
    {
 
        // traverse for all pairs
        // bottom-up approach
        for ( $j = 0; $j < $i - 1; $j++)
        {
 
            // dp-condition
            if ($dp[$i] < $dp[$j] + $arr[$i])
            {
                $dp[$i] = $dp[$j] + $arr[$i];
 
                // find maximum sum
                if ($maxi < $dp[$i])
                    $maxi = $dp[$i];
            }
        }
    }
 
    // return the maximum
    return $maxi;
}
 
// Function to find the maximum sum
// from 1st position to n-1-th position
function maxSum2($arr, $n)
{
    $dp[$n] = array();
    $maxi = 0;
 
    for ($i = 1; $i < $n; $i++)
    {
        $dp[$i] = $arr[$i];
 
        if ($maxi < $arr[$i])
            $maxi = $arr[$i];
    }
 
    // Traverse from third to n-th pos
    for ($i = 3; $i < $n; $i++)
    {
 
        // bottom-up approach
        for ($j = 1; $j < $i - 1; $j++)
        {
 
            // dp condition
            if ($dp[$i] < $arr[$i] + $dp[$j])
            {
                $dp[$i] = $arr[$i] + $dp[$j];
 
                // find max sum
                if ($maxi < $dp[$i])
                    $maxi = $dp[$i];
            }
        }
    }
 
    // return max
    return $maxi;
}
 
function findMaxSum($arr, $n)
{
    return max(maxSum1($arr, $n),
               maxSum2($arr, $n));
}
 
// Driver Code
$arr = array(1, 2, 3, 1 );
$n = sizeof($arr);
echo findMaxSum($arr, $n);
     
//  This code is contributed
// by Sach_Code
?>
Javascript



<script>
 
// JavaScript program to find maximum sum
// in a circular array such that
// no elements are adjacent in the sum.
 
// Function to calculate the sum
// from 0th position to(n-2)th position
function maxSum1(arr, n)
{
    let dp = new Array(n);
    let maxi = 0;
 
    for (i = 0; i < n - 1; i++)
    {
 
        // copy the element of original
        // array to dp[]
        dp[i] = arr[i];
 
        // find the maximum element
        // in the array
        if (maxi < arr[i])
            maxi = arr[i];
    }
 
    // start from 2nd to n-1th pos
    for (i = 2; i < n - 1; i++)
    {
 
        // traverse for all pairs
        // bottom-up approach
        for (j = 0; j < i - 1; j++)
        {
 
            // dp-condition
            if (dp[i] < dp[j] + arr[i])
            {
                dp[i] = dp[j] + arr[i];
 
                // find maximum sum
                if (maxi < dp[i])
                    maxi = dp[i];
            }
        }
    }
 
    // return the maximum
    return maxi;
}
 
// Function to find the maximum sum
// from 1st position to n-1-th position
function maxSum2(arr, n)
{
    let dp = new Array(n);
    let maxi = 0;
 
    for (i = 1; i < n; i++)
    {
        dp[i] = arr[i];
 
        if (maxi < arr[i])
            maxi = arr[i];
    }
 
    // Traverse from third to n-th pos
    for (i = 3; i < n; i++)
    {
 
        // bottom-up approach
        for (j = 1; j < i - 1; j++)
        {
 
            // dp condition
            if (dp[i] < arr[i] + dp[j])
            {
                dp[i] = arr[i] + dp[j];
 
                // find max sum
                if (maxi < dp[i])
                    maxi = dp[i];
            }
        }
    }
 
    // return max
    return maxi;
}
 
function findMaxSum(arr, n)
{
    let t = Math.max(maxSum1(arr, n),
                     maxSum2(arr, n));
    return t;
}
 
// Driver Code
 
let arr = [1, 2, 3, 1 ];
let n = arr.length;
document.write(findMaxSum(arr, n));
 
// This code is contributed by mohit kumar 29.
</script>
Output: 
4
 
Time Complexity: O(N^2) 
 

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

Maximum sum such that no two elements are adjacent | Set 2
Recommended Articles
Page :
Maximum sum in circular array such that no two elements are adjacent | Set 2
08, May 20
Arrange N elements in circular fashion such that all elements are strictly less than sum of adjacent elements
11, Jul 19
Minimize the maximum absolute difference of adjacent elements in a circular array
30, Apr 20
Maximum count of adjacent pairs with even sum in given Circular Array
22, Dec 21
Maximum sum in a 2 x n grid such that no two elements are adjacent
08, Jun 17
Maximum sum such that no two elements are adjacent | Set 2
14, May 19
Maximum sub-sequence sum such that indices of any two adjacent elements differs at least by 3
26, Jun 19
Maximum sum such that exactly half of the elements are selected and no two adjacent
27, Apr 20
Maximum sum such that no two elements are adjacent
26, Nov 09
Minimize Array sum by replacing elements such that Relation among adjacent elements in maintained
31, Mar 22
Minimum absolute difference of adjacent elements in a circular array
28, Oct 17
Check if all elements of a Circular Array can be made equal by increments of adjacent pairs
18, Aug 20
Maximum sum of nodes in Binary tree such that no two are adjacent | Dynamic Programming
28, Mar 19
Maximize sum of given array by rearranging array such that the difference between adjacent elements is atmost 1
25, Oct 20
Maximum sum of Array formed by replacing each element with sum of adjacent elements
23, Apr 20
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
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
Generate a circular permutation with number of mismatching bits between pairs of adjacent elements exactly 1
16, Feb 21
Sum of elements in 1st array such that number of elements less than or equal to them in 2nd array is maximum
17, 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
Make all array elements even by replacing adjacent pair of array elements with their sum
21, Dec 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Mohd_Saliem
@Mohd_Saliem
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!