Sliding Subarray Beauty - Leetcode Solution

The "Sliding Subarray Beauty" problem on LeetCode asks for the maximum beauty of all subarrays of length k in an array of integers. Beauty of a subarray is defined as the difference between the maximum and minimum value in the subarray.

We can solve this problem using the sliding window technique. We can maintain a window of size k and move it over the array, calculating the beauty of each subarray as we go.

Here is the step-by-step solution:

1. Initialize two pointers, left and right, to the start of the array. Initialize a hash table, freq, to keep track of the frequency of each element in the current window.

2. Move the right pointer k steps to the right and update the freq table accordingly.

3. Calculate the maximum and minimum value in the current window and calculate the beauty of the subarray.

4. Repeat steps 2-3 until the right pointer reaches the end of the array.

5. Return the maximum beauty found in all subarrays.

Here is the Python code for the solution:

from collections import defaultdict

class Solution:
    def beautySum(self, nums: List[int], k: int) -> int:
        left, right = 0, k - 1
        freq = defaultdict(int)
        beauty = 0
        
        # Initialize frequency table for the first window
        for i in range(k):
            freq[nums[i]] += 1
        
        # Compute max and min values for the first window
        max_val = max(freq.keys())
        min_val = min(freq.keys())
        
        # Compute beauty of the first subarray
        beauty = max_val - min_val
        
        # Slide the window k steps to the right and update the freq table
        while right < len(nums) - 1:
            left += 1
            right += 1
            freq[nums[left-1]] -= 1
            freq[nums[right]] += 1
            
            # Update max and min values based on the changes in the window
            if freq[max_val] == 0:
                del freq[max_val]
                max_val = max(freq.keys())
            if freq[min_val] == 0:
                del freq[min_val]
                min_val = min(freq.keys())
            
            # Compute beauty of the current subarray and update the maximum beauty found so far
            beauty = max(beauty, max_val - min_val)
        
        return beauty

The time complexity of this solution is O(n), where n is the length of the input array. This is because we iterate over the array only once and perform constant time operations for each iteration. The space complexity is O(k), where k is the window size, because we maintain a frequency table of size k.

1