Data Structures and Algorithms: Delete and Earn

Welcome to CodeYourCraft! Today, we're diving into a fascinating problem known as Delete and Earn. This problem is a great way to understand the importance of algorithms and data structures in real-world applications.

Introduction 🎯

In the Delete and Earn problem, you're given a list of integers nums, where each integer represents the price of a certain type of coin. If you decide to sell a coin, you earn its value. However, you can only sell consecutive coins of the same value, and you can sell each such group of coins only once.

Your goal is to find the maximum total value you can earn from this list. Let's dive in and see how we can solve this problem!

Understanding the Problem 📝

Before we write any code, let's discuss the problem and understand it better.

We have a list of integers nums. Each integer represents the price of a coin.
We can only sell consecutive coins of the same value, and we can sell each such group only once.
The objective is to maximize the total value we can earn.

Breaking it Down 💡

To solve this problem, we'll use a simple greedy algorithm. Greedy algorithms make the locally optimal choice at each step with the hope of finding a global optimum.

Greedy Approach

Sort the list in descending order.
Iterate through the sorted list and keep a variable maxEarnings to store the maximum earnings so far.
For each coin, calculate the potential earnings by multiplying the coin value by the length of the remaining coins that have the same value.
If the potential earnings are greater than maxEarnings, update maxEarnings with the new potential earnings.
At the end, maxEarnings will hold the maximum total value that can be earned.

Implementing the Solution ✅

Let's implement the solution in Python:

python

def deleteAndEarn(nums):
    nums.sort(reverse=True)
    freq = [0] * 10001

    # Calculate the frequency of each coin value in the list
    for num in nums:
        freq[num] += 1

    # Array to store the maximum earnings possible for each coin value
    maxEarnings = [0] * 10001

    # Base case: if there's only one coin, its value is the maximum earnings
    maxEarnings[nums[0]] = nums[0]

    # Iterate through the sorted list and calculate the maximum earnings for each coin value
    for num in range(1, len(nums)):
        for j in range(num, min(num + 1000, len(nums))):
            maxEarnings[nums[j]] = max(maxEarnings[nums[j]], nums[j] * freq[nums[j]] + maxEarnings[nums[j - 1]])

    # The maximum total value that can be earned is the sum of the maximum earnings for each coin value
    totalEarnings = sum(maxEarnings)
    return totalEarnings

Testing Our Solution 💡

Now that we've implemented the solution, let's test it with some examples:

python

nums1 = [3, 4, 2]
print(deleteAndEarn(nums1))  # Output: 6

nums2 = [2, 2, 3, 3, 3, 4]
print(deleteAndEarn(nums2))  # Output: 9

With this, we've learned about the Delete and Earn problem and implemented a solution using a greedy algorithm. This problem serves as a great introduction to solving real-world problems using data structures and algorithms. Keep exploring and coding with CodeYourCraft! 🌟