The idea is to store the frequency of each number from 0 to maximum element range M.

Now for each element from 0 to M, there are two choices: either we pick it or skip it.

So, we can break the problem into subproblems using following observation:

1. If we pick element ‘x’,  we must skip ‘x’ + 1.
2. If we don’t pick ‘x’ then we may pick ‘x’ + 1 or skip it.

Let P(i, d) be the maximum point we can collect by picking elements from ‘i’ to M, where 0 <= d <=1, if d is 0 it means we have picked the previous( i - 1 th) element else not.

Then,

P(i, 0) = max( P(i + 1, 1) + frequency[i] * i, P(i + 1, 0))

P(i, 1) = P(i + 1, 0)

This gives the optimal substructure.

If you observe, there are repetitive subproblems. We can avoid the recomputation of those repetitive subproblems by memoization.

Algorithm :

The steps are as follows:

• Run a loop from 0 to ‘n’ and store the maximum element in the variable ‘M’.
• Take a frequency array ‘frequency’ and store the initial frequency of all elements from 1 to ‘M’ to 0.
• Run a loop from 0 to 'n'.
  • Update the frequency of each number Frequency[ arr[i] ]++.
• Take a 2D array of size 2 * M, let's say ‘dp’ and initialize it with -1.
• Make a helper function ‘helper(frequency, idx, M, d, dp).
• Take a variable ‘ans’ and store the maximum of helper(frequency, 0, M, 0) and helper(frequency, 0, M, 1).
• Return the final answer ‘ans’.
•  

Description of helper(frequency, idx, M, d) function

• If 'idx' is equal to 'n' return 0.
• If dp[d][idx] is not equal to -1
  • Return ‘dp[d][idx]’.
• Take the variable 'ans'.
• If 'd' is equal to 0, it means previous element was not picked:
  • Store the maximum of when we pick element at 'idx' and if we don't pick it and store in ‘ans’  i.e ‘ans’ = max(helper(frequency, idx + 1, n, 1) + frequency[idx] * idx, helper(frequency, idx + 1, n, 0)).
• Else previous element was picked:
  • Skip this element and recursively call the ‘helper’ function on the next index i.e ‘ans’ = helper(frequency, idx + 1, n, 0).
• Update ‘dp’ i.e dp[d][idx] = ‘ans’.
• Return ‘ans’.

Before coming to this question, what if array elements contain all the numbers from 1 to ‘N’. like 1, 2, 3, 4, 5, 6. Then you can clearly say that , if I select ith element then i will not select ‘i’ - 1 th element and if I don’t select ith element then to maximize points we must select i -1 th element. So, for every element there are two states either it is selected or not. Now this problem can give the sense of using dp ..right?

Similarly we can generalize this for duplicate elements like 1, 1, 2, 3, 3, 4, 4, 5.

We can keep the frequency of each element. The elements which are not present in the array then their frequency is 0. 

State : 

1. dp[i] , the maximum points till ith element.

Transition: 

1. if ith element is selected then points = dp[i - 2] + i * frequency[i].
2. If ith element is not selected then dp[i] is equal to dp[i - 1]. The answer will be the maximum number of above two.
3. So dp[i] = max(dp[i-1],  dp[i-2] + i * frequency[i]);.

Algorithm :

The steps are as follows:

• Run a loop from 0 to ‘n’ and store the maximum element in the variable ‘M’.
• Take a frequency array ‘frequency’ and store the initial frequency of all elements from 1 to M i.e  0.
• Run a loop from 0 to 'n' and update the frequency of each number.
• Take a 'dp' array of length M  it stores the maximum Points till 'i'.
• Initialize 'dp[0]' to 0 and dp[1] equal to frequency[1].
• Run a loop from 2 to 1000 and update the value of dp[i]
  • dp[i] = max(dp[i-1],  dp[i-2] + i * frequency[i]).
• Return dp[M].