Skip to content
Related Articles

Related Articles

Maximize the sum of selected numbers from an array to make it empty
  • Difficulty Level : Hard
  • Last Updated : 26 Mar, 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 occureneces 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[] in a hash ans. Now our recurrence relation will decide either to select a number or not. If we select the number then we take the occurrences of that number and the value stored at ans[i-2] as ans[i-1] will be deleted and not be taken to count. If we do not select the number then we take ans[i-1] which have been pre-calculated while moving forward. 
 

ans[i] = max(ans[i-1], ans[i-2] + ans[i]*i )

At the end, ans[maximum] will have the maximum sum of selected numbers. 
Below is the implementation of above idea: 
 

C++




// CPP program to Maximize the sum of selected
// numbers by deleting three consecutive numbers.
#include <bits/stdc++.h>
using namespace std;
 
// function to maximize the sum of selected numbers
int maximizeSum(int a[], int n) {
 
  // stores the occurrences of the numbers
  unordered_map<int, int> ans;
 
  // marks the occurrence of every number in the sequence
  for (int i = 0; i < n; i++)
    ans[a[i]]++;
 
  // maximum in the sequence
  int maximum = *max_element(a, a + n);
 
  // traverse till maximum and apply the recurrence relation
  for (int i = 2; i <= maximum; i++)
    ans[i] = max(ans[i - 1], ans[i - 2] + ans[i] * i); 
 
  // return the ans stored in the index of maximum
  return ans[maximum];
}
 
// Driver code
int main()
{
  int a[] = {1, 2, 3};
  int n = sizeof(a) / sizeof(a[0]);
  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
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 []ans = new int[max + 1];
     
    for(int i = 0; i < n; i++)
    {
        ans[arr[i]]++;
    }
     
    // Using the above mentioned approach
    for(int i = 2; i <= max; i++)
    {
        ans[i] = Math.max(ans[i - 1], ans[i - 2] + i* ans[i]);
    }
     
    return ans[max];
     
}
 
// Driver code
public static void main(String[] args)
{
    int []a = {1, 2, 3};
 
    System.out.println(getMaximumSum(a));
}
}
 
// This code is contributed by Sooraj Kumar (NITS CSE 2020)

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) :
 
    # 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
 
    # maximum in the sequence
    maximum = max(a)
 
    # traverse till maximum and apply
    # the recurrence relation
    for i in range(2, maximum + 1) :
        ans[i] = max(ans[i - 1],
                     ans[i - 2] + ans[i] * i)
 
    # return the ans stored in the
    # index of maximum
    return ans[maximum]
 
# 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;
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 = -1;
    for(int i = 0; i < n; i++)
    {
        max = Math.Max(max, arr[i]);
    }
     
    // An array to count the occurence of each element
    int []ans = new int[max + 1];
     
    for(int i = 0; i < n; i++)
    {
        ans[arr[i]]++;
    }
     
    // Using the above mentioned approach
    for(int i = 2; i <= max; i++)
    {
        ans[i] = Math.Max(ans[i - 1],
                          ans[i - 2] + i* ans[i]);
    }
    return ans[max];
}
 
// 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




<script>
 
    // Javascript implementation of the approach
     
    // Function to maximise the sum of selected nummbers
    //by deleting occurences of Ai-1 and Ai+1
    function getMaximumSum(arr)
    {
        // Number of elements in the array
        let n = arr.length;
 
        // Largest element in the array
        let max = -1;
        for(let i = 0; i < n; i++)
        {
            max = Math.max(max, arr[i]);
        }
 
        // An array to count the occurence of each element
        let ans = new Array(max + 1);
        ans.fill(0);
 
        for(let i = 0; i < n; i++)
        {
            ans[arr[i]]++;
        }
 
        // Using the above mentioned approach
        for(let i = 2; i <= max; i++)
        {
            ans[i] = Math.max(ans[i - 1], ans[i - 2] + i* ans[i]);
        }
 
        return ans[max];
 
    }
 
    let a = [1, 2, 3];
     
    document.write(getMaximumSum(a));
 
</script>

Output: 

4

Time Complexity: O(Amax), where Amax is the maximum element present in the 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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :