Delete and Earn

dp[i] = max(dp[i-1], dp[i-2] + points[i])

Compute the optimal score for value i using the DP recurrence.

This recurrence encodes the fundamental decision of the problem. Taking value i yields points[i] but prevents selecting i−1, so the best compatible previous result is dp[i−2]. Skipping value i preserves dp[i−1]. Choosing the maximum of these options guarantees that adjacent values are never selected simultaneously while maximizing total reward.

freq = Counter(nums)

Count how many times each number appears in nums.

The original array must be reorganized by value rather than position because the deletion rule depends on numerical adjacency (x removes x−1 and x+1). Aggregating frequencies converts scattered duplicates into a single total reward per value, which is necessary to reduce the problem into a one-dimensional dynamic programming structure.

points = [0] * (max_val + 1)

Create an array where index i stores the total reward obtainable from value i.

The points array converts the frequency information into total reward per value. Each index now represents a decision point: taking value i yields points[i] but forbids taking i−1 and i+1. This transformation reshapes the problem into an adjacency-constrained selection problem.

points[v] = v * c

Compute the total points contributed by each value.

If the algorithm chooses value v, it will take every occurrence of v because duplicates do not conflict with each other. Multiplying the value by its frequency correctly aggregates the full reward obtainable from that choice.

dp = [0] * (max_val + 1)

Initialize the DP array that will store optimal scores for each value prefix.

The DP array stores optimal results for progressively larger value ranges. Specifically, dp[i] represents the maximum points achievable using values from 0 through i while respecting the adjacency restriction.

return dp[max_val]

Return the optimal total points.

After processing all values up to max_val, dp[max_val] contains the best achievable reward under the adjacency constraint. This value represents the optimal solution for the entire problem.

max_val = max(nums)

Determine the largest value in nums to size the value-indexed arrays.

The dynamic programming process iterates across possible numeric values rather than array positions. Determining the largest value establishes the upper bound of the value domain so that the DP and reward arrays cover every possible number that could influence the optimal solution.

dp[1] = points[1]

Establish the base case for value 1.

The recurrence depends on dp[i−1] and dp[i−2], so the smallest meaningful state must be established first. Setting dp[1] anchors the DP computation and ensures later transitions have valid base values.

for v, c in freq.items():

Iterate through each unique value and its frequency.

Iterating through the frequency map populates the reward structure used by the DP. This step compresses all duplicates of the same number into a single aggregated decision, which simplifies later transitions.

for i in range(2, max_val + 1):

Iterate through each value from 2 up to max_val.

Processing values sequentially ensures that when computing dp[i], both dp[i−1] and dp[i−2] have already been determined. This ordering preserves the dependency structure of the recurrence.