# 2841. Maximum Sum of Almost Unique Subarray

## Problem Statement

<br>

You are given an integer array `nums` and two positive integers `m` and `k`.

Return *the **maximum sum** out of all **almost unique** subarrays of length* `k` *of* `nums`. If no such subarray exists, return `0`.

A subarray of `nums` is **almost unique** if it contains at least `m` distinct elements.

A subarray is a contiguous **non-empty** sequence of elements within an array.

&#x20;

**Example 1:**

<pre><code><strong>Input: nums = [2,6,7,3,1,7], m = 3, k = 4
</strong><strong>Output: 18
</strong><strong>Explanation: There are 3 almost unique subarrays of size k = 4. These subarrays are [2, 6, 7, 3], [6, 7, 3, 1], and [7, 3, 1, 7]. Among these subarrays, the one with the maximum sum is [2, 6, 7, 3] which has a sum of 18.
</strong></code></pre>

**Example 2:**

<pre><code><strong>Input: nums = [5,9,9,2,4,5,4], m = 1, k = 3
</strong><strong>Output: 23
</strong><strong>Explanation: There are 5 almost unique subarrays of size k. These subarrays are [5, 9, 9], [9, 9, 2], [9, 2, 4], [2, 4, 5], and [4, 5, 4]. Among these subarrays, the one with the maximum sum is [5, 9, 9] which has a sum of 23.
</strong></code></pre>

**Example 3:**

<pre><code><strong>Input: nums = [1,2,1,2,1,2,1], m = 3, k = 3
</strong><strong>Output: 0
</strong><strong>Explanation: There are no subarrays of size k = 3 that contain at least m = 3 distinct elements in the given array [1,2,1,2,1,2,1]. Therefore, no almost unique subarrays exist, and the maximum sum is 0.
</strong></code></pre>

&#x20;

**Constraints:**

* `1 <= nums.length <= 2 * 104`
* `1 <= m <= k <= nums.length`
* `1 <= nums[i] <= 109`

## Intuition

```
Approach:
Apply sliding window for a window and find ans
```

### Links

<https://leetcode.com/problems/maximum-sum-of-almost-unique-subarray/>

### Video Links

### Approach 1:

```
Sliding window
```

{% code title="C++" lineNumbers="true" %}

```cpp
class Solution {
public:
    long long maxSum(vector<int>& arr, int m, int k) {
        long long ans = 0, window_sum=0;
        unordered_map<int,int> mp;
        int low=0, high;
        
        for(high=0; high<k; high++){
            mp[arr[high]]++;
            window_sum += arr[high];
        }

        if(mp.size() >= m)
            ans = max(ans, window_sum);

        while (high<arr.size()) {
            if(mp[arr[low]] == 1)
                mp.erase(arr[low]);
            else
                mp[arr[low]]--;
            window_sum -= arr[low++];

            mp[arr[high]]++;
            window_sum += arr[high++];

            if(mp.size() >= m)
                ans = max(ans, window_sum);
        }

        return ans;  
    }
};
```

{% endcode %}

### Approach 2:

```
```

{% code title="C++" lineNumbers="true" %}

```cpp
```

{% endcode %}

### Approach 3:

```
```

{% code title="C++" lineNumbers="true" %}

```cpp
```

{% endcode %}

### Approach 4:

```
```

{% code title="C++" lineNumbers="true" %}

```cpp
```

{% endcode %}

### Similar Problems

###


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://coding-9.gitbook.io/untitled/sliding-window/medium/2841.-maximum-sum-of-almost-unique-subarray.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.