Delete and Earn - Practice Coding Problems

Delete and Earn - Problem

Delete and Earn is a strategic optimization problem where you need to maximize points by carefully choosing which numbers to delete from an array.

🎯 The Challenge: You're given an integer array nums. Each time you pick a number nums[i], you earn nums[i] points, but there's a catch - you must also delete all occurrences of nums[i] - 1 and nums[i] + 1 from the array!

Goal: Return the maximum number of points you can earn by applying this operation optimally.

Example: With array [3, 4, 2], if you pick 4 (earning 4 points), you must delete all 3s and 5s. This strategic constraint makes the problem similar to the classic House Robber problem!

Input & Output

example_1.py — Basic Case

$ Input: [3, 4, 2]

› Output: 6

💡 Note: You can perform operations: take 4 (earning 4 points, must delete 3s and 5s), then take 2 (earning 2 points, must delete 1s and 3s). Total: 4 + 2 = 6 points.

example_2.py — Duplicates

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

› Output: 9

💡 Note: Take all three 3s (earning 3+3+3 = 9 points). This forces deletion of all 2s and 4s, but 9 > 4+4 = 8, so this is optimal.

example_3.py — Single Element

$ Input: [1]

› Output: 1

💡 Note: Only one element exists, so take it for 1 point. No adjacent elements to worry about.

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
1 ≤ nums[i] ≤ 10⁴
Follow-up: Can you solve it in O(n) time?

Visualization

Tap to expand

Understanding the Visualization

Survey the Cave

Count how many chests of each number exist and calculate total treasure per number

Apply the Ancient Rule

Use House Robber logic: for each number, decide whether to take it or skip it based on maximum benefit

Make Strategic Choices

Adjacent numbers create conflicts - choose the combination that maximizes total treasure

Collect Maximum Gold

The DP solution ensures we get the theoretical maximum possible treasure

Key Takeaway

🎯 Key Insight: Transform the problem into House Robber by grouping identical numbers and applying the constraint that adjacent numbers cannot both be selected. This reduces a complex optimization problem into a well-known DP pattern with O(n) solution!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution recognizes this as a House Robber variant. Create an array where points[i] represents total points for number i, then apply dynamic programming with the recurrence dp[i] = max(dp[i-1], dp[i-2] + points[i]). This achieves O(n + k) time complexity where k is the maximum number, making it extremely efficient for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized DP with Range-Based Approach	O(n + k)	O(k)	Use array indexing for numbers in range, avoiding sorting completely
Brute Force (Try All Combinations)	O(2^n)	O(n)	Generate all possible valid combinations and find the one with maximum sum
Dynamic Programming with Frequency Map	O(n log n)	O(n)	Count frequencies first, then use DP to solve House Robber variant

Optimized DP with Range-Based Approach — Algorithm Steps

Find the maximum number to determine array size needed
Create points array where points[i] = total points for number i
Apply House Robber DP: dp[i] = max(dp[i-1], dp[i-2] + points[i])
Return the maximum points achievable

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Points Array

Index i stores total points for number i

Fill Array

Add each number to its corresponding index

Apply House Robber

DP with adjacent constraint: dp[i] = max(dp[i-1], dp[i-2] + points[i])

Return Result

Final DP value gives maximum points possible

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int rob(int* points, int size) {
    int prev2 = 0, prev1 = 0;
    for (int i = 0; i < size; i++) {
        int curr = max(prev1, prev2 + points[i]);
        prev2 = prev1;
        prev1 = curr;
    }
    return prev1;
}

int deleteAndEarn(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    
    int maxNum = nums[0];
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] > maxNum) {
            maxNum = nums[i];
        }
    }
    
    int* points = (int*)calloc(maxNum + 1, sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        points[nums[i]] += nums[i];
    }
    
    int result = rob(points, maxNum + 1);
    free(points);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n + k)

O(n) to process input + O(k) for DP where k is the maximum number in array

✓ Linear Growth

Space Complexity

O(k)

Array of size k where k is the maximum number, plus DP array

✓ Linear Space

78.4K Views

High Frequency

~15 min Avg. Time

1.9K 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

Optimized DP with Range-Based Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler