<p>You are given an integer array <code>nums</code> and an integer <code>k</code>. Find the maximum subarray sum of all the subarrays of <code>nums</code> that meet the following conditions:</p>

<ul>
	<li>The length of the subarray is <code>k</code>, and</li>
	<li>All the elements of the subarray are <strong>distinct</strong>.</li>
</ul>

<p>Return <em>the maximum subarray sum of all the subarrays that meet the conditions</em><em>.</em> If no subarray meets the conditions, return <code>0</code>.</p>

<p><em>A <strong>subarray</strong> is a contiguous non-empty sequence of elements within an array.</em></p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> nums = [1,5,4,2,9,9,9], k = 3
<strong>Output:</strong> 15
<strong>Explanation:</strong> The subarrays of nums with length 3 are:
- [1,5,4] which meets the requirements and has a sum of 10.
- [5,4,2] which meets the requirements and has a sum of 11.
- [4,2,9] which meets the requirements and has a sum of 15.
- [2,9,9] which does not meet the requirements because the element 9 is repeated.
- [9,9,9] which does not meet the requirements because the element 9 is repeated.
We return 15 because it is the maximum subarray sum of all the subarrays that meet the conditions
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> nums = [4,4,4], k = 3
<strong>Output:</strong> 0
<strong>Explanation:</strong> The subarrays of nums with length 3 are:
- [4,4,4] which does not meet the requirements because the element 4 is repeated.
We return 0 because no subarrays meet the conditions.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= k &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
	<li><code>1 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
</ul>

class Solution:
    def maximumSubarraySum(self, nums: List[int], k: int) -> int:
        elementsInSubarray = set()
        maxSum = 0
        currentKSum = 0

        firstElementIndex = 0
        lastElementIndex = 0
        while lastElementIndex<len(nums):
            while(nums[lastElementIndex] in elementsInSubarray):
                elementsInSubarray.remove(nums[firstElementIndex])
                currentKSum -= nums[firstElementIndex]
                firstElementIndex += 1

            currentKSum += nums[lastElementIndex] 
            elementsInSubarray.add(nums[lastElementIndex])
            
            # updates max sum if k elements
            if lastElementIndex - firstElementIndex == k-1:

                maxSum = max(maxSum,currentKSum)
                currentKSum -= nums[firstElementIndex]
                elementsInSubarray.remove(nums[firstElementIndex])
                firstElementIndex += 1
            lastElementIndex += 1

        return maxSum

    def slowmaximumSubarraySum(self, nums: List[int], k: int) -> int:
        elementsInSubarray = {}
        maxSum = 0
        currentKSum = 0
        duplicateIndex = -1

        def duplicateCheckAndUpdate(elementValue, elementIndex, duplicateIndex):
            elementsInSubarray.setdefault(elementValue,[])
            elementDuplicates = elementsInSubarray[elementValue]
            if len(elementDuplicates) is not 0:
                # take the last element for the latest duplicate
                duplicateIndex = max(duplicateIndex, elementDuplicates[len(elementDuplicates)-1])
            
            elementsInSubarray[elementValue].append(elementIndex)
            return duplicateIndex

        #inital k subarray
        for i in range(0,k):
            duplicateIndex = duplicateCheckAndUpdate(nums[i], i, duplicateIndex)
            currentKSum += nums[i]

        if duplicateIndex == -1:
            maxSum = currentKSum

        # search rest of possible subarrays
        for i in range (k,len(nums)):
            removeElementIndex = i-k
            removeElement = nums[removeElementIndex]
            newElementIndex = i
            newElement = nums[newElementIndex]

            duplicateIndex = duplicateCheckAndUpdate(newElement, newElementIndex,duplicateIndex)

            currentKSum += (newElement - removeElement)
            #check for duplicates 
            if duplicateIndex <= removeElementIndex:
                print(removeElementIndex, " to ", newElementIndex)
                maxSum = max(maxSum,currentKSum)
        return maxSum

32100