Delete and Earn

Delete and Earn - Problem

You are given an integer array nums. You want to maximize the number of points you get by performing the following operation any number of times:

Pick any nums[i] and delete it to earn nums[i] points. Afterwards, you must delete every element equal to nums[i] - 1 and every element equal to nums[i] + 1.

Return the maximum number of points you can earn by applying the above operation some number of times.

Input & Output

Example 1 — Basic Case

$ Input: nums = [3,4,2]

› Output: 6

💡 Note: Delete 4 to earn 4 points (removes 3). Then delete 2 to earn 2 points. Total: 4 + 2 = 6

Example 2 — Multiple Same Values

$ Input: nums = [2,2,3,3,3,4]

› Output: 9

💡 Note: Delete all 3's to earn 3×3=9 points (removes all 2's and 4's). This is better than taking 2's and 4's for 2×2+4=8 points

Example 3 — Single Element

$ Input: nums = [1]

› Output: 1

💡 Note: Only one element, so delete it to earn 1 point

Constraints

1 ≤ nums.length ≤ 2×10⁴
1 ≤ nums[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to transform this into a House Robber problem by counting frequencies of each unique number. Since taking a number eliminates adjacent values, we can't take consecutive numbers. Best approach is frequency count + DP. Time: O(n log k), Space: O(k) where k is unique numbers.

Common Approaches

✓ Frequency Count + Dynamic Programming

⏱️ Time: O(n log n) Space: O(k)

Transform the problem by counting frequency of each number, then treat it as House Robber where adjacent houses (consecutive numbers) cannot both be robbed.

Memoized Recursion

⏱️ Time: O(k) Space: O(k)

Use recursion with memoization to solve subproblems. For each number, decide whether to take it (and skip adjacent) or skip it. Cache results to avoid recomputing same states.

Recursive Backtracking

⏱️ Time: O(2ⁿ) Space: O(n)

For each unique element, recursively try taking it (and removing adjacent values) or skipping it. Explore all possibilities to find maximum points.

Frequency Count + Dynamic Programming — Algorithm Steps

Count frequency of each unique number
Sort unique numbers
Apply House Robber DP: for each number, choose max(take + dp[i-2], skip)

Visualization

Tap to expand

Step-by-Step Walkthrough

Count & Sort

Count frequencies and sort unique numbers

DP Logic

For each number, choose max(take + dp[i-2], skip)

Final Answer

Return dp[last] as maximum points

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_NUMS 10000

static int count[20001];
static int uniqueNums[MAX_NUMS];
static int dp[MAX_NUMS];

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int solution(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    
    memset(count, 0, sizeof(count));
    int uniqueCount = 0;
    
    // Count frequencies
    for (int i = 0; i < numsSize; i++) {
        count[nums[i] + 10000]++;
    }
    
    // Get unique numbers
    for (int i = 0; i < 20001; i++) {
        if (count[i] > 0) {
            uniqueNums[uniqueCount++] = i - 10000;
        }
    }
    
    qsort(uniqueNums, uniqueCount, sizeof(int), compare);
    
    if (uniqueCount == 1) {
        return uniqueNums[0] * count[uniqueNums[0] + 10000];
    }
    
    // DP array
    dp[0] = uniqueNums[0] * count[uniqueNums[0] + 10000];
    
    if (uniqueNums[1] == uniqueNums[0] + 1) {
        int take = uniqueNums[1] * count[uniqueNums[1] + 10000];
        dp[1] = (dp[0] > take) ? dp[0] : take;
    } else {
        dp[1] = dp[0] + uniqueNums[1] * count[uniqueNums[1] + 10000];
    }
    
    // Fill DP table
    for (int i = 2; i < uniqueCount; i++) {
        int take = uniqueNums[i] * count[uniqueNums[i] + 10000];
        
        if (uniqueNums[i] == uniqueNums[i-1] + 1) {
            int option1 = dp[i-1];
            int option2 = take + dp[i-2];
            dp[i] = (option1 > option2) ? option1 : option2;
        } else {
            dp[i] = dp[i-1] + take;
        }
    }
    
    return dp[uniqueCount - 1];
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int nums[MAX_NUMS];
    int numsSize = 0;
    
    char* token = strtok(line, "[,]");
    while (token != NULL && numsSize < MAX_NUMS) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(nums, numsSize);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Counting frequencies O(n) + sorting unique numbers O(k log k) where k ≤ n

⚡ Linearithmic

Space Complexity

O(k)

Hash map for frequencies and array for unique numbers, k = unique count

✓ Linear Space

158.0K Views

Medium Frequency

~25 min Avg. Time

3.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Frequency Count + Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler