Skip to content
Related Articles
Maximize the sum of selected numbers from an array to make it empty
• Difficulty Level : Hard
• Last Updated : 31 May, 2021

Given an array of N numbers, we need to maximize the sum of selected numbers. At each step, you need to select a number Ai, delete one occurrence of it and delete all occurrences of Ai-1 and Ai+1 (if they exist) in the array. Repeat these steps until the array gets empty. The problem is to maximize the sum of the selected numbers.
Note: We have to delete all the occurrences of Ai+1 and Ai-1 elements if they are present in the array and not Ai+1 and Ai-1.
Examples:

```Input : a[] = {1, 2, 3}
Output : 4
Explanation: At first step we select 1, so 1 and
2 are deleted from the sequence leaving us with 3.
Then we select 3 from the sequence and delete it.
So the sum of selected numbers is 1+3 = 4.

Input : a[] =  {1, 2, 2, 2, 3, 4}
Output : 10
Explanation : Select one of the 2's from the array, so
2, 2-1, 2+1 will be deleted and we are left with {2, 2, 4},
since 1 and 3 are deleted. Select 2 in next two steps,
and then select 4 in the last step.
We get a sum of 2+2+2+4=10 which is the maximum possible. ```

Our aim is to maximize the sum of selected numbers. The idea is to pre-calculate the occurrence of all numbers x in the array a[].

Approach:

• Calculate the MAX value in the array.
• Create an array of size MAX and store the occurrences of each element in it.
• Since we want to maximize our answer, we will start iterating from the MAX value to 0.
• If the occurrence of the ith element is greater than 0, then add it to our answer decrease the occurrences of the i-1th element by 1, and also decrease the occurrence of ith by 1 since we have added it to our answer.
• We don’t have to decrease the occurrence of the i+1th element because we are already starting from the end so i+1th is already processed.
• There might be multiple occurrences of the ith element that’s why do not decrease i yet, to stay on the same element.

Below is the implementation of above idea:

## C++

 `// CPP program to Maximize the sum of selected``// numbers by deleting three consecutive numbers.``#include ``using` `namespace` `std;` `// function to maximize the sum of selected numbers``int` `maximizeSum(``int` `arr[], ``int` `n) {` `      ``// Largest element in the array``    ``int` `mx = -1;``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``mx = max(mx, arr[i]);``    ``}   ``    ` `    ``// An array to count the occurence of each element``    ``int` `freq[mx + 1];``    ` `    ``memset``(freq, 0, ``sizeof``(freq));``    ` `    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``freq[arr[i]]++;``    ``}``    ` `    ``// ans to store the result``    ``int` `ans = 0, i=mx;``    ` `    ``// Using the above mentioned approach``    ``while``(i>0){``        ` `        ``// if occurence is greater than 0``        ``if``(freq[i] > 0){``            ``// add it to ans``            ``ans += i;``            ` `            ``// decrease i-1th element by 1``            ``freq[i-1]--;``            ` `            ``// decrease ith element by 1``            ``freq[i]--;``        ``}``else``{``            ``// decrease i``            ``i--;``        ``}       ``    ``}``    ` `    ``return` `ans;``}` `// Driver code``int` `main()``{``  ``int` `a[] = {1, 2, 3};``  ``int` `n = ``sizeof``(a) / ``sizeof``(a);``  ``cout << maximizeSum(a, n);``  ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;``import` `java.math.*;` `class` `GFG``{``      ``// Function to maximise the sum of selected nummbers``      ``//by deleting occurences of Ai-1 and Ai+1``    ``public` `static` `int` `getMaximumSum (``int` `arr[]) {``        ` `        ``// Number of elements in the array``        ``int` `n = arr.length;``        ` `        ``// Largest element in the array``        ``int` `max = -``1``;``        ``for``(``int` `i = ``0``; i < n; i++)``        ``{``            ``max = Math.max(max, arr[i]);``        ``}``        ` `        ``// An array to count the occurence of each element``        ``int` `[]freq = ``new` `int``[max + ``1``];``        ` `        ``for``(``int` `i = ``0``; i < n; i++)``        ``{``            ``freq[arr[i]]++;``        ``}``        ` `        ``// ans to store the result``        ``int` `ans = ``0``, i=max;``        ` `        ``// Using the above mentioned approach``        ``while``(i>``0``){``            ` `            ``// if occurence is greater than 0``            ``if``(freq[i] > ``0``){``                ``// add it to ans``                ``ans += i;``                ` `                ``// decrease i-1th element by 1``                ``freq[i-``1``]--;``                ` `                ``// decrease ith element by 1``                ``freq[i]--;``            ``}``else``{               ``                ``// decrease i``                ``i--;``            ``}           ``        ``}``        ` `        ``return` `ans;``    ``}` `      ``// Driver code``      ``public` `static` `void` `main(String[] args)``      ``{``          ``int` `[]a = {``1``, ``2``, ``3``};` `          ``System.out.println(getMaximumSum(a));``      ``}``}`

## Python3

 `# Python3 program to Maximize the sum of selected``# numbers by deleting three consecutive numbers.` `# function to maximize the sum of``# selected numbers``def` `maximizeSum(a, n) :` `        ``# maximum in the sequence``    ``maximum ``=` `max``(a)``    ` `    ``# stores the occurrences of the numbers``    ``ans ``=` `dict``.fromkeys(``range``(``0``, n ``+` `1``), ``0``)` `    ``# marks the occurrence of every``    ``# number in the sequence``    ``for` `i ``in` `range``(n) :``        ``ans[a[i]] ``+``=` `1``        ` `    ``# ans to store the result``    ``result ``=` `0``    ``i ``=` `maximum``    ` `    ``# Using the above mentioned approach``    ``while` `i > ``0``:``        ` `        ``# if occurence is greater than 0``        ``if` `ans[i] > ``0``:``            ``# add it to ans``            ``result ``+``=` `i;``            ` `            ``# decrease i-1th element by 1``            ``ans[i``-``1``] ``-``=` `1``;``            ` `            ``# decrease ith element by 1``            ``ans[i] ``-``=` `1``;``        ``else``:          ``            ``# decrease i``            ``i ``-``=` `1``;``    ` `    ``return` `result;` `# Driver code``if` `__name__ ``=``=` `"__main__"` `:` `    ``a ``=` `[``1``, ``2``, ``3``]``    ``n ``=` `len``(a)``    ``print``(maximizeSum(a, n))` `# This code is contributed by Ryuga`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Linq;` `class` `GFG``{` `// Function to maximise the sum of selected nummbers``//by deleting occurences of Ai-1 and Ai+1``static` `int` `getMaximumSum(``int` `[]arr)``{``    ``// Number of elements in the array``    ``int` `n = arr.Length;` `    ``// Largest element in the array``    ``int` `max = arr.Max();` `    ``// An array to count the occurence of each element``    ``int` `[]freq = ``new` `int``[max + 1];` `    ``for``(``int` `j = 0; j < n; j++)``    ``{``      ``freq[arr[j]]++;``    ``}` `    ``// ans to store the result``    ``int` `ans = 0, i=max;` `    ``// Using the above mentioned approach``    ``while``(i>0){` `      ``// if occurence is greater than 0``      ``if``(freq[i] > 0){``        ``// add it to ans``        ``ans += i;` `        ``// decrease i-1th element by 1``        ``freq[i-1]--;` `        ``// decrease ith element by 1``        ``freq[i]--;``      ``}``else``{               ``        ``// decrease i``        ``i--;``      ``}           ``    ``}` `    ``return` `ans;``}` `// Driver code``public` `static` `void` `Main(``string``[] args)``{``    ``int` `[]a = {1, 2, 3};` `    ``Console.Write(getMaximumSum(a));``}``}` `// This code is contributed by rock_cool`

## Javascript

 ``

Output:

`4`

Time Complexity: Time Complexity will be the sum of (Amax + Highest occurrence of element in arr), because if the frequency is greater than 1 then we are processing that element multiple times.

-where Amax is the maximum element present in array A[].

Space Complexity: O(Amax ), where Amax is the maximum element present in array A[].

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up