Given an array of N numbers, we need to maximize the sum of selected numbers. At each step, you need to select a number A_{i}, delete one occurrence of it and delete all occurrences of **A _{i}-1** and

**A**(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.

_{i}+1**Note:**We have to delete all the occurrences of A

_{i}+1 and A

_{i}-1 elements if they are present in the array and not A

_{i+1}and A

_{i-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 i
^{th}element is greater than 0, then add it to our answer decrease the occurrences of the i-1^{th}element by 1, and also decrease the occurrence of i^{th}by 1 since we have added it to our answer. - We don’t have to decrease the occurrence of the i+1
^{th }element because we are already starting from the end so i+1^{th}is already processed. - There might be multiple occurrences of the i
^{th}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 (A_{max }+_{ }Highest occurrence of element in arr), because if the frequency is greater than 1 then we are processing that element multiple times.

-where A_{max} is the maximum element present in array A[].

**Space Complexity: **O(A_{max }), where A_{max} 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**