# 1695. Maximum Erasure Value

#### Medium

***

You are given an array of positive integers `nums` and want to erase a subarray containing **unique elements**. The **score** you get by erasing the subarray is equal to the **sum** of its elements.

Return *the **maximum score** you can get by erasing **exactly one** subarray.*

An array `b` is called to be a subarray of `a` if it forms a contiguous subsequence of `a`, that is, if it is equal to `a[l],a[l+1],...,a[r]` for some `(l,r)`.

 

**Example 1:**

```
Input: nums = [4,2,4,5,6]
Output: 17
Explanation: The optimal subarray here is [2,4,5,6].
```

**Example 2:**

```
Input: nums = [5,2,1,2,5,2,1,2,5]
Output: 8
Explanation: The optimal subarray here is [5,2,1] or [1,2,5].
```

 

**Constraints:**

* `1 <= nums.length <= 105`
* `1 <= nums[i] <= 104`

```python
class Solution:
    def maximumUniqueSubarray(self, nums: List[int]) -> int:
        # Solving in same way as Longest Substring without repeating chars
        result, index = 0, 0
        d = defaultdict(lambda:-1)
        prefix_sum = self.prefix_sum(nums)
        start = 0
        while index < len(nums):
            start = max(start, d[nums[index]] +1)
            # Earlier I was using sum(nums[start : index + 1]) instaed of prefix sum
            # which was causing timeouts.
            result = max(result, (prefix_sum[index+1] - prefix_sum[start]))
            d[nums[index]] = index
            index += 1
        return result
    
    def prefix_sum(self, nums):
        result = [0]*(len(nums)+1)
        for index in range(1, len(result)):
            num = nums[index-1]
            result[index] = (num + result[index-1])
        return result
```