使用 Map 计算所有大小为 K 的子数组的最小值和最大值

给定一个由N 个整数组成的数组 arr[]和一个整数K ，任务是找到所有大小为 K 的子数组的最小值和最大值。

例子：

Input: arr[] = {2, -2, 3, -9, -5, -8}, K = 4
Output:
-9 3
-9 3
-9 3
Explanation:
Below are the subarray of size 4 and minimum and maximum value of each subarray:
1. {2, -2, 3, -9}, minValue = -9, maxValue = 3
2. {-2, 3, -9, -5}, minValue = -9, maxValue = 3
3. {3, -9, -5, -8}, minValue = -9, maxValue = 3

Input: arr[] = { 5, 4, 3, 2, 1, 6, 3, 5, 4, 2, 1 }, K = 3
Output:
3 5
2 4
1 3
1 6
1 6
3 6
3 5
2 5
1 4

方法：

1. 遍历给定数组最多 K 个元素，并将每个元素的计数存储到映射中。
2. 插入 K 个元素后，对每个剩余的元素执行以下操作：
   • 将当前元素arr[i]的频率增加 1。
   • 将 arr[i – K + 1]的频率减 1 以存储大小为K的当前子数组( arr[i – K + 1, i] )的频率。
   • 由于 map 按排序顺序存储键值对。因此，地图开头的迭代器存储最小元素，而地图末尾的迭代器存储最大元素。打印当前子数组的最小和最大元素。
3. 对形成的每个子阵列重复上述步骤。

下面是上述方法的实现：

// C++ program for the above approach
  
#include 
using namespace std;
  
// Function to find the minimum and
// maximum element for each subarray
// of size K
int maxSubarray(int arr[], int n, int k)
{
  
    // To store the frequency of element
    // for every subarray
    map Map;
  
    // To count the subarray array size
    // while traversing array
    int l = 0;
  
    // Traverse the array
    for (int i = 0; i < n; i++) {
  
        // Increment till we store the
        // frequency of first K element
        l++;
  
        // Update the count for current
        // element
        Map[arr[i]]++;
  
        // If subarray size is K, then
        // find the minimum and maximum
        // for each subarray
        if (l == k) {
  
            // Iterator points to end
            // of the Map
            auto itMax = Map.end();
            itMax--;
  
            // Iterator points to start of
            // the Map
            auto itMin = Map.begin();
  
            // Print the minimum and maximum
            // element of current sub-array
            cout << itMin->first << ' '
                 << itMax->first << endl;
  
            // Decrement the frequency of
            // arr[i - K + 1]
            Map[arr[i - k + 1]]--;
  
            // if arr[i - K + 1] is zero
            // remove from the map
            if (Map[arr[i - k + 1]] == 0) {
                Map.erase(arr[i - k + 1]);
            }
  
            l--;
        }
    }
    return 0;
}
  
// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { 5, 4, 3, 2, 1, 6,
                  3, 5, 4, 2, 1 };
  
    // Subarray size
    int k = 3;
  
    int n = sizeof(arr) / sizeof(arr[0]);
  
    // Function Call
    maxSubarray(arr, n, k);
    return 0;
}

输出：

3 5
2 4
1 3
1 6
1 6
3 6
3 5
2 5
1 4

时间复杂度： O(N*log K) ，其中 N 是元素的数量。
辅助空间： O(K) ，其中 K 是子数组的大小。

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live