Maximum Sum Such That No Two Elements Are Adjacent in Java

In this tutorial, we are going to discuss how to compute the maximum sum such that no two elements are adjacent in Java. In the input, an array (inptArr[]) filled with positive numbers is given.

Example 1:

Input

int inptArr[] = {15, 15, 110, 1100, 110, 15, 7, 80}

Output

1210

Explanation:

We consider the subset {15, 1100, 15, 80}, and we get the sum 1210, which is the maximum sum when the two elements of the subset are not adjacent if we take the reference of the input array.

Example 2:

Input

int inptArr[] = {3, 15, 11, 7, 180}

Output

195

Explanation:

We consider the subset {15, 1100, 15, 80}, and we get the sum 1210, which is the maximum sum when the two elements of the subset are not adjacent if we take the reference of the input array.

Simple Approach

The simple approach is the brute force approach for this problem. In this approach, we will find all the possible subsets of the given input array. In the found subsets, we will check which one is the valid subset (for this problem, valid subsets are those subsets whose two elements are not adjacent). For the valid subsets, we will be computing the sum and updating our answer as per the largest sum found.

FileName: MaxSumAdjEle.java

// importing ArrayList as it is used
// by the program
import java.util.ArrayList;

public class MaxSumAdjEle 
{
// a list that contains the indexes of the elements 
//  of the input array
ArrayList<Integer> al = new ArrayList<Integer>();
int maxVal = 0; // our answer

// if any of the pairs (of adjacent elements) has a difference of only one
// then the method returns false; otherwise, true
public boolean isValidList(ArrayList<Integer> al)
{
int size = al.size();
for(int i = 0; i < size - 1; i++)
{
if((al.get(i) + 1) == al.get(i + 1))
{
return false;
}
}

return true;
}

public int findVal(ArrayList<Integer> al, int inptArr[])
{
// if the list is not valid as per the problem
// statement, then return 0
if(!isValidList(al))
{
    return 0;
}


// size of the list
int size = al.size();
int sumVal = 0;

// finding the sum of elements
for(int i = 0; i < size; i++)
{
sumVal = sumVal + inptArr[al.get(i)];  
}

return sumVal;
}


public void findMaxSumAdjEle(int inptArr[], int k, int l)
{

if(k > l)
{
// computing the value and checking whether it is the 
// maximum value or not. If yes, then update the maximum value
int tmpVal = findVal(al, inptArr);
maxVal = Math.max(maxVal, tmpVal);
return;
}

// recursively computing all of the subsets
// to do so, either the element has to be included or excluded
// from the list

// including the elements in the list
al.add(k); 
findMaxSumAdjEle(inptArr, k + 1, l);


// excluding the elements from the list
al.remove(al.size() - 1); 
findMaxSumAdjEle(inptArr, k + 1, l);

}

public static void main(String argvs[])
{
// creating an object of the class MaxSumAdjEle
MaxSumAdjEle obj = new MaxSumAdjEle();

// input 1
int inptArr[] = {15, 15, 110, 1100, 110, 15, 7, 80};
int size = inptArr.length;

obj.findMaxSumAdjEle(inptArr, 0, size - 1);


System.out.println("For the input array: ");
for(int i = 0 ; i < size; i++)
{
System.out.print(inptArr[i] + " ");
}
System.out.println( );


System.out.println("The Maximum Sum Such That No Two Elements Are Adjacent is: " + obj.maxVal);

System.out.println( "\n" );

// resetting the value
obj.maxVal = 0;
obj.al.clear();

// input 2
int inptArr1[] = {3, 15, 11, 7, 180};
size = inptArr1.length;

obj.findMaxSumAdjEle(inptArr1, 0, size - 1);


System.out.println("For the input array: ");
for(int i = 0 ; i < size; i++)
{
System.out.print(inptArr1[i] + " ");
}
System.out.println( );


System.out.println("The Maximum Sum Such That No Two Elements Are Adjacent is: " + obj.maxVal);


}
}

Output:

For the input array: 
15 15 110 1100 110 15 7 80 
The Maximum Sum Such That No Two Elements Are Adjacent is: 1210


For the input array: 
3 15 11 7 180 
The Maximum Sum Such That No Two Elements Are Adjacent is: 195

Complexity Analysis: Each recursive call gives birth to a recursive call (one excluding the element, and the other includes the element). Hence, the time complexity of the program is exponential. The space complexity of the program is linear as the recursive calls are using stack. Thus, the time complexity of the program is O(2ⁿ). The space complexity of the program O(n), where n is the total size of the input array.

Approach: Using Dynamic Programming

The above program shows that each element has two choices. If that element is selected, then its neighbors can not be selected. If that element is not selected, then its neighbors can or can not be selected.

Hence, the maximum sum till the j^th index has two possibilities: one is the subsequence that includes inputArr[j] or the other one that excludes inputArr[j].

If we include the element inputArr[j] is included, then the maximum sum is dependent on the maximum sum of subsequence until (j - 1)^th element. It is obvious that we will be excluding element inputArr[j - 1], as inputArr[j] is already included.

If we exclude the element inputArr[j], then the maximum sum is the same as the maximum sum of subsequences till (j - 1), where the element inputArr[j - 1] can either be included or excluded.

So we have to build a 2-D array dpArr[N][2] where dp[i][0] keeps the maximum sum of subsequence till j^th index with inputArr[i] excluded, and dpArr[j][1] keeps the sum when the inputArr[i] is included.

Thus, we get the following relation in this dynamic programming approach.

dpArr[j][1] = dpArr[j - 1][0] + inputArr[j] and dpArr[j][0] = max(dpArr[j - 1][0], dpArr[j - 1][1]).

Now, see the following steps required to achieve the solution.

Step 1: If the array size is 1, then the answer is inputArr[0].

Step 2: Initialize the values of dpArr[0][0] = 0 and dpArr[0][1] = inputArr[0].

Step 3: Iterate from j = 1 to Siz - 1:

Fill the dpArr[] array according to the above-shown relation.

Step 3: Return the maximum between dpArr[Siz - 1][1] and dpArr[Siz - 1][0].

Observe the following program.

FileName: MaxSumAdjEle1.java

public class MaxSumAdjEle1
{

// Method for finding the maximum sum
public int findMaxSumAdjEle(int[] inputArr, int siz)
{
	// Declaring the dp array
	int[][] dpArr = new int[siz][2];
	if (siz == 1) 
	{
	    return inputArr[0];
	}

	// Initializing the values of the dpArr[]
	dpArr[0][0] = 0;
	dpArr[0][1] = inputArr[0];

	// Loop for finding the maximum sum
	for (int j = 1; j < siz; j++) 
	{
	dpArr[j][1] = dpArr[j - 1][0] + inputArr[j];
	dpArr[j][0] = Math.max(dpArr[j - 1][1], dpArr[j - 1][0]);
	}

	// Returning the maximum sum
	return Math.max(dpArr[siz - 1][0], dpArr[siz - 1][1]);
}


public static void main(String argvs[])
{
// creating an object of the class MaxSumAdjEle1
MaxSumAdjEle1 obj = new MaxSumAdjEle1();

// input 1
int inptArr[] = {15, 15, 110, 1100, 110, 15, 7, 80};
int size = inptArr.length;

int ans = obj.findMaxSumAdjEle(inptArr, size);


System.out.println("For the input array: ");
for(int i = 0 ; i < size; i++)
{
System.out.print(inptArr[i] + " ");
}
System.out.println( );


System.out.println("The Maximum Sum Such That No Two Elements Are Adjacent is: " + ans);

System.out.println( "\n" );

// input 2
int inptArr1[] = {3, 15, 11, 7, 180};
size = inptArr1.length;

ans = obj.findMaxSumAdjEle(inptArr1, size);


System.out.println("For the input array: ");
for(int i = 0 ; i < size; i++)
{
System.out.print(inptArr1[i] + " ");
}
System.out.println( );


System.out.println("The Maximum Sum Such That No Two Elements Are Adjacent is: " + ans);


}

}

Output:

For the input array: 
15 15 110 1100 110 15 7 80 
The Maximum Sum Such That No Two Elements Are Adjacent is: 1210


For the input array: 
3 15 11 7 180 
The Maximum Sum Such That No Two Elements Are Adjacent is: 195

Complexity Analysis: There is only one loop that is required to find the maximum sum. Hence, the time complexity of the program is O(n). Also, the program uses an array that contains twice the number of input elements. Hence, the space complexity of the program is O(2 x n), asymptotically represented as O(n), where n is the total number of elements present in the input array.

Space Optimized Approach

If we look at the above program, we see that the current state of the jth element is only dependent on the two states of the last element encountered. Therefore, instead of the created an array, we can only use two variables.

One variable is inclsv, which keeps the value of the maximum sum of subsequence till j - 1 when inputArr[j - 1] is included.

Another variable is exclsv, which keeps the value of the maximum sum of subsequence till j - 1 when inputArr[j - 1] is excluded.

Illustration:

Consider inputArr[] = {15,  15, 110, 1100, 110, 15}

In the beginning, at j = 0:  inclsv = 15, exclsv = 0

For j = 1: inputArr[j] = 15
        => exclNew = 15
        => inclsv = (exclsv + inputArr[j]) = 15
        => exclsv = exclNew = 15

For j = 2: inputArr[j] = 110
        => exclNew =  max(exclsv, inclsv) = 15
        => inclsv =  (exclsv + inputArr[j]) = 125
        => exclsv = exclNew = 15

For j = 3: inputArr[j] = 1100
        => exclNew =  max(exclsv, inclsv) = 125
        => inclsv =  (exclsv + inputArr[j]) = 1115
        => exclsv = exclNew = 125

For j = 4: inputArr[j] = 110
        => exclNew =  max(exclsv, inclsv) = 1115
        => inclsv =  (exclsv + inputArr[j]) = 235
        => exclsv = exclNew = 1115

For j = 5: inputArr[j] = 15
        => exclNew =  max(exclsv, inclsv) = 1115
        => inclsv =  (exclsv + inputArr[j]) = 1130
        => exclsv = exclNew = 1115

So, answer is maxOf(inclsv, exclsv) =  1130

FileName: MaxSumAdjEle2.java

public class MaxSumAdjEle2
{

// Method for finding the maximum sum
public int findMaxSumAdjEle(int[] inputArr, int siz)
{
int inclsv = inputArr[0];
int exclsv = 0;
int exclNew;
int j;

for (j = 1; j < siz; j++) 
{
// Current maximum excluding j
exclNew = Math.max(inclsv, exclsv);

// Current maximum including j
inclsv = exclsv + inputArr[j];
exclsv = exclNew;
}

// Returning the maximum of inclsv and exclsv
return Math.max(inclsv, exclsv);
}


public static void main(String argvs[])
{
// creating an object of the class MaxSumAdjEle2
MaxSumAdjEle2 obj = new MaxSumAdjEle2();

// input 1
int inptArr[] = {15, 15, 110, 1100, 110, 15, 7, 80};
int size = inptArr.length;

int ans = obj.findMaxSumAdjEle(inptArr, size);


System.out.println("For the input array: ");
for(int i = 0 ; i < size; i++)
{
System.out.print(inptArr[i] + " ");
}
System.out.println( );


System.out.println("The Maximum Sum Such That No Two Elements Are Adjacent is: " + ans);

System.out.println( "\n" );

// input 2
int inptArr1[] = {3, 15, 11, 7, 180};
size = inptArr1.length;

ans = obj.findMaxSumAdjEle(inptArr1, size);


System.out.println("For the input array: ");
for(int i = 0 ; i < size; i++)
{
System.out.print(inptArr1[i] + " ");
}
System.out.println( );


System.out.println("The Maximum Sum Such That No Two Elements Are Adjacent is: " + ans);


}

}

Output:

For the input array: 
15 15 110 1100 110 15 7 80 
The Maximum Sum Such That No Two Elements Are Adjacent is: 1210


For the input array: 
3 15 11 7 180 
The Maximum Sum Such That No Two Elements Are Adjacent is: 195

Complexity Analysis: The time complexity of the program is the same as the last program, whereas the space complexity of the program is O(1).

Next TopicReverse a String in Place in Java

← prev next →