# Solving Leetcode Interviews in Seconds with AI: Maximum Unique Subarray Sum After Deletion


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3487" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are given an integer array nums. You are allowed to delete any number of elements from nums without making it empty. After performing the deletions, select a subarray of nums such that:  All elements in the subarray are unique. The sum of the elements in the subarray is maximized.  Return the maximum sum of such a subarray.   Example 1:  Input: nums = [1,2,3,4,5] Output: 15 Explanation: Select the entire array without deleting any element to obtain the maximum sum.  Example 2:  Input: nums = [1,1,0,1,1] Output: 1 Explanation: Delete the element nums[0] == 1, nums[1] == 1, nums[2] == 0, and nums[3] == 1. Select the entire array [1] to obtain the maximum sum.  Example 3:  Input: nums = [1,2,-1,-2,1,0,-1] Output: 3 Explanation: Delete the elements nums[2] == -1 and nums[3] == -2, and select the subarray [2, 1] from [1, 2, 1, 0, -1] to obtain the maximum sum.    Constraints:  1 <= nums.length <= 100 -100 <= nums[i] <= 100  

	# Explanation
	Here's the solution to the problem:

*   **Sliding Window with a Set:** Use a sliding window approach to maintain a subarray with unique elements. A set is used to efficiently track the elements currently within the window.

*   **Expanding and Contracting the Window:** Expand the window to the right as long as the new element is not already present in the set. If a duplicate is encountered, contract the window from the left until the duplicate is removed from the set.

*   **Maximize the Sum:** Keep track of the current sum of the elements in the window and update the maximum sum encountered so far.

*   **Runtime Complexity:** O(n), where n is the length of the input array. **Storage Complexity:** O(k), where k is the number of unique elements in the input array (in the worst case O(n)).

	
	# Code
	```python
	def maximumUniqueSubarray(nums):
    """
    Finds the maximum sum of a subarray with unique elements.

    Args:
        nums: A list of integers.

    Returns:
        The maximum sum of a subarray with unique elements.
    """

    max_sum = 0
    current_sum = 0
    seen = set()
    left = 0

    for right in range(len(nums)):
        while nums[right] in seen:
            current_sum -= nums[left]
            seen.remove(nums[left])
            left += 1

        current_sum += nums[right]
        seen.add(nums[right])
        max_sum = max(max_sum, current_sum)

    return max_sum
	```