Skip to content
Related Articles

Related Articles

Improve Article
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 <bits/stdc++.h>
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[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
    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




<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 = Number.MIN_VALUE;
        for(let i = 0; i < n; i++)
        {
            max = Math.max(max, arr[i]);
        }
 
        // An array to count the occurence of each element
        let freq = new Array(max + 1);
        freq.fill(0);
 
        for(let j = 0; j < n; j++)
        {
          freq[arr[j]]++;
        }
 
        // ans to store the result
        let 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;
    }
     
    let a = [1, 2, 3];
  
    document.write(getMaximumSum(a));
     
    // This code is contributed by suresh07.
</script>

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
Recommended Articles
Page :