<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and an integer <code>k</code>.</p>

<p>You can perform the following operation on the array <strong>at most</strong> <code>k</code> times:</p>

<ul>
	<li>Choose any index <code>i</code> from the array and <strong>increase</strong> or <strong>decrease</strong> <code>nums[i]</code> by <code>1</code>.</li>
</ul>

<p>The score of the final array is the <strong>frequency</strong> of the most frequent element in the array.</p>

<p>Return <em>the <strong>maximum</strong> score you can achieve</em>.</p>

<p>The frequency of an element is the number of occurences of that element in the array.</p>

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

<pre>
<strong>Input:</strong> nums = [1,2,6,4], k = 3
<strong>Output:</strong> 3
<strong>Explanation:</strong> We can do the following operations on the array:
- Choose i = 0, and increase the value of nums[0] by 1. The resulting array is [2,2,6,4].
- Choose i = 3, and decrease the value of nums[3] by 1. The resulting array is [2,2,6,3].
- Choose i = 3, and decrease the value of nums[3] by 1. The resulting array is [2,2,6,2].
The element 2 is the most frequent in the final array so our score is 3.
It can be shown that we cannot achieve a better score.
</pre>

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

<pre>
<strong>Input:</strong> nums = [1,4,4,2,4], k = 0
<strong>Output:</strong> 3
<strong>Explanation:</strong> We cannot apply any operations so our score will be the frequency of the most frequent element in the original array, which is 3.
</pre>

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

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

class Window:
    def __init__(self):
        self.dq = deque()
        self.l = 0
        self.m = None
        self.count = 0

    def append(self, val):
        self.dq.append(val)
        new_l = self.l + 1
        new_m = self.dq[new_l // 2]

        if new_l == 1:
            self.count = 0
        else:
            self.count += (self.l // 2 + 1) * (new_m - self.m)
            self.count -= (self.l - self.l // 2 - 1) * (new_m - self.m)
            self.count += val - new_m

        self.l = new_l
        self.m = new_m
        return self.count

    def pop(self):
        val = self.dq.popleft()
        new_l = self.l - 1
        new_m = self.dq[new_l // 2]

        if new_l == 1:
            self.count = 0
        else:
            self.count += (new_l // 2) * (new_m - self.m)
            self.count -= (new_l - new_l // 2) * (new_m - self.m)
            self.count -= self.m - val

        self.l = new_l
        self.m = new_m
        return self.count


class Solution:
    def maxFrequencyScore(self, nums: List[int], k: int) -> int:
        nums.sort()
        n = len(nums)

        sw = Window()

        ans = 0
        for i in range(n):
            count = sw.append(nums[i])
            while count > k:
                count = sw.pop()

            ans = max(ans, sw.l)

        return ans

"""
0 1 2 3 4 
    ^
0 1 2 3 4 5
      ^

0 1 2 3 4 5
      ^
1 2 3 4 5
    ^
2 3 4 5
    ^
"""
1272