# Sliding SubArray Beauty

## Problem Statement

Given an integer array nums containing n integers, find the beauty of each subarray of size k.

The beauty of a subarray is the xth smallest integer in the subarray if it is negative, or 0 if there are fewer than x negative integers.

Return an integer array containing n - k + 1 integers, which denotes the beauty of the subarrays in order from the first index in the array.

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

### Example:

Input: nums = [-1,-2,-3,-4,-5], k = 2, x = 2

Output: [-1,-2,-3,-4]

Explanation:

• For the given input array nums = [-1, -2, -3, -4, -5], with a subarray size k = 2 and target value x = 2, there are 4 subarrays of size 2. The first subarray is [-1, -2], and the 2nd smallest negative integer is -2. The second subarray is [-2, -3], and the 2nd smallest negative integer is -3. The third subarray is [-3, -4], and the 2nd smallest negative integer is -4. The fourth subarray is [-4, -5], and the 2nd smallest negative integer is -4. Therefore, the output is [-1, -2, -3, -4].

## Java Implementation

### Java Brute Force Approach

Output:

Code Explanation:

• The algorithm processes an array nums of integers, sliding a window of size k across it. For each window, it maintains a frequency map map. The map is updated as the window slides, incrementing the count of each number encountered and decrementing the count of the outgoing number.
• The minimum value within the desired range x is determined using the findMin method. The results are collected in a list and converted to an array. This approach efficiently computes the minimum value in each subarray of size k as the window moves through the array, providing an array of minimum values for each window.

Time Complexity:

• The time complexity of the algorithm is O(N), where N is the length of the input array nums. The algorithm processes each element once and maintains a constant-size frequency map during the sliding window operation.

Space Complexity:

• The space complexity is O(1) as the size of the frequency map is constant, independent of the input size. The additional space required is proportional to the range of numbers in the array, which NUM_RANGE bounds.

Drawback:

• The algorithm's drawback is that it relies on a fixed range (NUM_RANGE) to represent numbers. If the range is significantly larger than the actual range of numbers in the input array, it may lead to unnecessary space usage.

### Java Approach Using Sliding Window

Output:

Code Explanation:

• The above Java program calculates a new array based on a sliding window over the input array. It uses a TreeMap to maintain the frequency of elements in the current window efficiently. The main method first takes the length and elements of the array, as well as the length of the subarray (k) and the value x from the user.
• The getSubarrayBeauty method initializes the TreeMap for the initial window, calculates the initial result, and then slides the window while updating the TreeMap. The result array stores the k-th smallest negative element for each window. The getKthSmallestNeg helper method iterates through the TreeMap to find the kth smallest negative element.

Time Complexity:

• The time complexity of the provided solution is O(N log K), where N is the length of the input array, and K is the length of the subarray. This is because the TreeMap operations (put and remove) take logarithmic time.

Space Complexity:

• The space complexity is O(K), as the TreeMap stores at most K distinct elements in the sliding window, where K is the length of the subarray.

• The advantage of the above solution over the brute force method lies in its optimized approach using a TreeMap. By maintaining a TreeMap to track the occurrences of elements in the sliding window, the algorithm efficiently updates and retrieves the k-th smallest negative element.
• This eliminates the need for repeated searches in each subarray, significantly reducing time complexity. The TreeMap allows for logarithmic time complexity in element retrieval, optimizing the overall performance compared to the brute force method, which has a higher time complexity due to repetitive computations.