Maximum sum in an array such that every element has exactly one adjacent element to it
Last Updated :
10 Aug, 2023
Given an array arr[] of N integers, you can select some indexes such that every selected index has exactly one other selected index adjacent to it and the sum of elements at the chosen indexes should be maximum.
In other words, the task is to select elements from an array such that a single element alone is not selected and elements at three consecutive indices are not selected and the sum of selected elements should be maximum.
The task is to print the maximized sum.
Examples:
Input: arr[] = {1, 2, 3, 1, 4}
Output: 8
arr[0] + arr[1] + arr[3] + arr[4] = 1 + 2 + 1 + 4 = 8
Input: arr[] = {1, 1, 1, 1}
Output: 2
Approach: Dynamic programming can be used to solve this problem. This problem can be translated to selecting pairs of adjacent integers such that no two pairs are adjacent or have an element in common
i.e. if (arr[i], arr[i + 1]) is a pair we selected then neither (arr[i + 2], arr[i + 3]) nor (arr[i + 1], arr[i + 2]) can be selected.
Let’s decide the states of the dp according to the above statement.
For every index i, we will either select indexes i and i + 1 i.e. make a pair or not make it. In case, we make a pair, we won’t be able to select the index i + 2 as it will make 2 elements adjacent to i + 1. So, we will have to solve for i + 3 next. If we don’t make a pair, we will simply solve for i + 1.
So the recurrence relation will be.
dp[i] = max(arr[i] + arr[i + 1] + dp[i + 3], dp[i + 1])
There are N states in total and each state takes O(1) time to solve. Thus, the time complexity will be O(N).
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
#define arrSize 51
using namespace std;
int dp[arrSize];
bool v[arrSize];
int sumMax(int i, int arr[], int n)
{
if (i >= n - 1)
return 0;
if (v[i])
return dp[i];
v[i] = true;
dp[i] = max(arr[i] + arr[i + 1]
+ sumMax(i + 3, arr, n),
sumMax(i + 1, arr, n));
return dp[i];
}
int main()
{
int arr[] = { 1, 1, 1, 1 };
int n = sizeof(arr) / sizeof(int);
cout << sumMax(0, arr, n);
return 0;
}
|
Java
import java.io.*;
class GFG
{
static int arrSize = 51;
static int dp[] = new int[arrSize];
static boolean v[] = new boolean[arrSize];
static int sumMax(int i, int arr[], int n)
{
if (i >= n - 1)
return 0;
if (v[i])
return dp[i];
v[i] = true;
dp[i] = Math.max(arr[i] + arr[i + 1]
+ sumMax(i + 3, arr, n),
sumMax(i + 1, arr, n));
return dp[i];
}
public static void main (String[] args)
{
int arr[] = { 1, 1, 1, 1 };
int n = arr.length;
System.out.println(sumMax(0, arr, n));
}
}
|
Python3
arrSize = 51
dp = [0 for i in range(arrSize)]
v = [False for i in range(arrSize)]
def sumMax(i,arr,n):
if (i >= n - 1):
return 0
if (v[i]):
return dp[i]
v[i] = True
dp[i] = max(arr[i] + arr[i + 1] + sumMax(i + 3, arr, n),
sumMax(i + 1, arr, n))
return dp[i]
if __name__ == '__main__':
arr = [1, 1, 1, 1]
n = len(arr)
print(sumMax(0, arr, n))
|
C#
using System;
class GFG
{
static int arrSize = 51;
static int []dp = new int[arrSize];
static bool []v = new bool[arrSize];
static int sumMax(int i, int []arr, int n)
{
if (i >= n - 1)
return 0;
if (v[i])
return dp[i];
v[i] = true;
dp[i] = Math.Max(arr[i] + arr[i + 1]
+ sumMax(i + 3, arr, n),
sumMax(i + 1, arr, n));
return dp[i];
}
public static void Main ()
{
int []arr = { 1, 1, 1, 1 };
int n = arr.Length;
Console.WriteLine(sumMax(0, arr, n));
}
}
|
Javascript
<script>
var arrSize = 51;
var dp = Array(arrSize);
var v = Array(arrSize);
function sumMax(i, arr, n)
{
if (i >= n - 1)
return 0;
if (v[i])
return dp[i];
v[i] = true;
dp[i] = Math.max(arr[i] + arr[i + 1]
+ sumMax(i + 3, arr, n),
sumMax(i + 1, arr, n));
return dp[i];
}
var arr = [1, 1, 1, 1];
var n = arr.length;
document.write( sumMax(0, arr, n));
</script>
|
Time Complexity: O(N), where N is the given size of the array.
Auxiliary Space: O(51), no extra space is required, so it is a constant.
Efficient approach : Using DP Tabulation method ( Iterative approach )
The approach to solve this problem is same but DP tabulation(bottom-up) method is better then Dp + memoization(top-down) because memoization method needs extra stack space of recursion calls.
Steps to solve this problem :
- Create a DP to store the solution of the subproblems.
- Initialize the DP with base cases
- Now Iterate over subproblems to get the value of current problem form previous computation of subproblems stored in DP
- Return the final solution stored in dp[0].
Implementation :
C++
#include <bits/stdc++.h>
#define arrSize 51
using namespace std;
int dp[arrSize];
int sumMax(int arr[], int n) {
dp[n-1] = dp[n] = dp[n+1] = 0;
for(int i=n-2; i>=0; i--) {
dp[i] = max(arr[i] + arr[i+1] + dp[i+3], dp[i+1]);
}
return dp[0];
}
int main()
{
int arr[] = {1,1,1,1};
int n = sizeof(arr) / sizeof(int);
cout << sumMax(arr, n);
return 0;
}
|
Java
import java.util.Arrays;
public class Main {
private static final int arrSize = 51;
private static int[] dp = new int[arrSize];
private static int sumMax(int[] arr, int n) {
dp[n - 1] = dp[n] = dp[n + 1] = 0;
for (int i = n - 2; i >= 0; i--) {
dp[i] = Math.max(arr[i] + arr[i + 1] + dp[i + 3], dp[i + 1]);
}
return dp[0];
}
public static void main(String[] args) {
int[] arr = {1, 1, 1, 1};
int n = arr.length;
System.out.println(sumMax(arr, n));
}
}
|
Python
import sys
sys.setrecursionlimit(10**7)
dp = [0] * 51
def sumMax(arr, n):
dp[n-1] = dp[n] = dp[n+1] = 0
for i in range(n-2, -1, -1):
dp[i] = max(arr[i] + arr[i+1] + dp[i+3], dp[i+1])
return dp[0]
if __name__ == '__main__':
arr = [1,1,1,1]
n = len(arr)
print(sumMax(arr, n))
|
C#
using System;
public class Program
{
const int arrSize = 51;
static int[] dp = new int[arrSize];
static int sumMax(int[] arr, int n)
{
dp[n - 1] = dp[n] = dp[n + 1] = 0;
for (int i = n - 2; i >= 0; i--) {
dp[i] = Math.Max(
arr[i] + arr[i + 1] + dp[i + 3], dp[i + 1]);
}
return dp[0];
}
public static void Main()
{
int[] arr = { 1, 1, 1, 1 };
int n = arr.Length;
Console.WriteLine(sumMax(arr, n));
}
}
|
Javascript
function sumMax(arr, n) {
const dp = Array(n + 2).fill(0);
for (let i = n - 2; i >= 0; i--) {
dp[i] = Math.max(arr[i] + arr[i + 1] + dp[i + 3], dp[i + 1]);
}
return dp[0];
}
const arr = [1, 1, 1, 1];
const n = arr.length;
console.log(sumMax(arr, n));
|
Output:
2
Time Complexity: O(N), where N is the given size of the array.
Auxiliary Space: O(51), no extra space is required, so it is a constant.
Similar Reads
Maximum sum such that exactly half of the elements are selected and no two adjacent
Given an array A containing N integers. Find the maximum sum possible such that exact floor(N/2) elements are selected and no two selected elements are adjacent to each other. (if N = 5, then exactly 2 elements should be selected as floor(5/2) = 2) For a simpler version of this problem check out thi
14 min read
Maximum sum in circular array such that no two elements are adjacent | Set 2
Given an array arr[] 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 where the last and the first elements are assumed adjacent. Examples: Input: arr[] = [2, 2, 3, 1, 2]Output: 5Explanation: Maximum stol
1 min read
Maximum sum in a 2 x n grid such that no two elements are adjacent
Given a rectangular grid of dimension 2 x n. We need to find out the maximum sum such that no two chosen numbers are adjacent, vertically, diagonally, or horizontally. Examples: Input: 1 4 5 2 0 0 Output: 7 If we start from 1 then we can add only 5 or 0. So max_sum = 6 in this case. If we select 2 t
8 min read
Minimize Array sum by replacing elements such that Relation among adjacent elements in maintained
Given an array arr[] of size N, the task is to minimize the array sum after replacing array elements with positive integers in a way such the relation among the adjacent elements (pattern of the array)is maintained. Note: If arr[i] = arr[i+1] then in the new array they both can be the same or one ca
7 min read
Maximum sub-sequence sum such that indices of any two adjacent elements differs at least by 3
Given an array arr[] of integers, the task is to find the maximum sum of any sub-sequence in the array such that any two adjacent elements in the selected sequence have at least a difference of 3 in their indices in the given array. In other words, if you select arr[i] then the next element you can
12 min read
Maximum element in an array such that its previous and next element product is maximum
Given an array arr[] of N integers, the task is to print the largest element among the array such that its previous and next element product is maximum.Examples: Input: arr[] = {5, 6, 4, 3, 2} Output: 6 The product of the next and the previous elements for every element of the given array are: 5 -
6 min read
Maximum difference between a pair of adjacent elements by excluding every element once
Given an array arr[] consisting of positive integers, the task is to find the maximum difference between any two adjacent elements after excluding each element from the array (except the first and last elements). Examples: Input: arr[] = [1, 3, 4, 7, 8]Output: [3, 4, 4]Explanation:Excluding i = 1: R
11 min read
Maximum sum of Array formed by replacing each element with sum of adjacent elements
Given an array arr[] of size N, the task is to find the maximum sum of the Array formed by replacing each element of the original array with the sum of adjacent elements.Examples: Input: arr = [4, 2, 1, 3] Output: 23 Explanation: Replacing each element of the original array with the sum of adjacent
9 min read
Generate an array of maximum sum such that each element exceeds all elements present either on its left or right
Given an array A[] consisting of N positive integers, the task is to construct an array B[] of size N having maximum possible sum of array elements satisfying the following criteria for every index i: The array element B[i] must be less than or equal to A[i].For every index i, B[i] must be greater t
10 min read
Rearrange the Array to maximize the elements which is smaller than both its adjacent elements
Given an array arr[] consisting of N distinct integers, the task is to rearrange the array elements such that the count of elements that are smaller than their adjacent elements is maximum. Note: The elements left of index 0 and right of index N-1 are considered as -INF. Examples: Input: arr[] = {1,
7 min read