给定一个大小为N的数组 arr[]和整数Y ，任务是找到大小为 Y 的所有子数组中最大和最小元素之间的所有差异的最小值。
例子：
Input: arr[] = { 3, 2, 4, 5, 6, 1, 9 } Y = 3
Output: 2
Explanation:
All subarrays of length = 3 are:
{3, 2, 4} where maximum element = 4 and minimum element = 2 difference = 2
{2, 4, 5} where maximum element = 5 and minimum element = 2 difference = 3
{4, 5, 6} where maximum element = 6 and minimum element = 4 difference = 2
{5, 6, 1} where maximum element = 6 and minimum element = 1 difference = 5
{6, 1, 9} where maximum element = 9 and minimum element = 6 difference = 3
Out of these minimum is 2.
Input: arr[] = { 1, 2, 3, 3, 2, 2 } Y = 4
Output: 1
Explanation:
All subarrays of length = 4 are:
{1, 2, 3, 3} maximum element = 3 and minimum element = 1 difference = 2
{2, 3, 3, 2} maximum element = 3 and minimum element = 2 difference = 1
{3, 3, 2, 2} maximum element = 3 and minimum element = 2 difference = 1
Out of these minimum is 1.
朴素的方法：朴素的想法是遍历[0, N – Y]范围内的每个索引i，使用另一个循环从第i个索引遍历到第(i + Y – 1)个索引，然后计算最小和最大元素在大小为Y的子数组中，因此计算第 i次迭代的最大和最小元素的差异。最后，通过检查差异，评估最小差异。
时间复杂度： O(N*Y)
辅助空间： O(1)
高效的方法：这个想法是使用讨论的方法的概念 下一个更大的元素文章。以下是步骤：
- 构建两个数组maxarr[]和minarr[] ，其中maxarr[]将存储第 i个索引处的元素的下一个元素的索引， minarr[]将存储小于该元素的下一个元素的索引在第i个索引处。
- 用 0初始化堆栈以存储上述两种情况下的索引。
- 对于每个索引， i在 [0, N – Y]范围内，使用嵌套循环和滑动窗口方法形成两个数组submax和submin。这些数组将在第i次迭代中存储子数组中的最大和最小元素。
- 最后，计算最小差异。
下面是上述方法的实现：
C++
// C++ program for the above approach
#include
using namespace std;
// Function to get the maximum of all
// the subarrays of size Y
vector get_submaxarr(int* arr,
int n, int y)
{
int j = 0;
stack stk;
// ith index of maxarr array
// will be the index upto which
// Arr[i] is maximum
vector maxarr(n);
stk.push(0);
for (int i = 1; i < n; i++) {
// Stack is used to find the
// next larger element and
// keeps track of index of
// current iteration
while (stk.empty() == false
and arr[i] > arr[stk.top()]) {
maxarr[stk.top()] = i - 1;
stk.pop();
}
stk.push(i);
}
// Loop for remaining indexes
while (!stk.empty()) {
maxarr[stk.top()] = n - 1;
stk.pop();
}
vector submax;
for (int i = 0; i <= n - y; i++) {
// j < i used to keep track
// whether jth element is
// inside or outside the window
while (maxarr[j] < i + y - 1
or j < i) {
j++;
}
submax.push_back(arr[j]);
}
// Return submax
return submax;
}
// Function to get the minimum for
// all subarrays of size Y
vector get_subminarr(int* arr,
int n, int y)
{
int j = 0;
stack stk;
// ith index of minarr array
// will be the index upto which
// Arr[i] is minimum
vector minarr(n);
stk.push(0);
for (int i = 1; i < n; i++) {
// Stack is used to find the
// next smaller element and
// keeping track of index of
// current iteration
while (stk.empty() == false
and arr[i] < arr[stk.top()]) {
minarr[stk.top()] = i;
stk.pop();
}
stk.push(i);
}
// Loop for remaining indexes
while (!stk.empty()) {
minarr[stk.top()] = n;
stk.pop();
}
vector submin;
for (int i = 0; i <= n - y; i++) {
// j < i used to keep track
// whether jth element is inside
// or outside the window
while (minarr[j] <= i + y - 1
or j < i) {
j++;
}
submin.push_back(arr[j]);
}
// Return submin
return submin;
}
// Function to get minimum difference
void getMinDifference(int Arr[], int N,
int Y)
{
// Create submin and submax arrays
vector submin
= get_subminarr(Arr, N, Y);
vector submax
= get_submaxarr(Arr, N, Y);
// Store initial difference
int minn = submax[0] - submin[0];
int b = submax.size();
for (int i = 1; i < b; i++) {
// Calculate temporary difference
int dif = submax[i] - submin[i];
minn = min(minn, dif);
}
// Final minimum difference
cout << minn << "\n";
}
// Driver Code
int main()
{
// Given array arr[]
int arr[] = { 1, 2, 3, 3, 2, 2 };
int N = sizeof arr / sizeof arr[0];
// Given subarray size
int Y = 4;
// Function Call
getMinDifference(arr, N, Y);
return 0;
} Python3
# Python3 program for the above approach
# Function to get the maximum of all
# the subarrays of size Y
def get_submaxarr(arr, n, y):
j = 0
stk = []
# ith index of maxarr array
# will be the index upto which
# Arr[i] is maximum
maxarr = [0] * n
stk.append(0)
for i in range(1, n):
# Stack is used to find the
# next larger element and
# keeps track of index of
# current iteration
while (len(stk) > 0 and
arr[i] > arr[stk[-1]]):
maxarr[stk[-1]] = i - 1
stk.pop()
stk.append(i)
# Loop for remaining indexes
while (stk):
maxarr[stk[-1]] = n - 1
stk.pop()
submax = []
for i in range(n - y + 1):
# j < i used to keep track
# whether jth element is
# inside or outside the window
while (maxarr[j] < i + y - 1 or
j < i):
j += 1
submax.append(arr[j])
# Return submax
return submax
# Function to get the minimum for
# all subarrays of size Y
def get_subminarr(arr, n, y):
j = 0
stk = []
# ith index of minarr array
# will be the index upto which
# Arr[i] is minimum
minarr = [0] * n
stk.append(0)
for i in range(1 , n):
# Stack is used to find the
# next smaller element and
# keeping track of index of
# current iteration
while (stk and arr[i] < arr[stk[-1]]):
minarr[stk[-1]] = i
stk.pop()
stk.append(i)
# Loop for remaining indexes
while (stk):
minarr[stk[-1]] = n
stk.pop()
submin = []
for i in range(n - y + 1):
# j < i used to keep track
# whether jth element is inside
# or outside the window
while (minarr[j] <= i + y - 1 or
j < i):
j += 1
submin.append(arr[j])
# Return submin
return submin
# Function to get minimum difference
def getMinDifference(Arr, N, Y):
# Create submin and submax arrays
submin = get_subminarr(Arr, N, Y)
submax = get_submaxarr(Arr, N, Y)
# Store initial difference
minn = submax[0] - submin[0]
b = len(submax)
for i in range(1, b):
# Calculate temporary difference
diff = submax[i] - submin[i]
minn = min(minn, diff)
# Final minimum difference
print(minn)
# Driver code
# Given array arr[]
arr = [ 1, 2, 3, 3, 2, 2 ]
N = len(arr)
# Given subarray size
Y = 4
# Function call
getMinDifference(arr, N, Y)
# This code is contributed by Stuti Pathak1
时间复杂度： O(N)
辅助空间： O(N)
如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live