📌  相关文章
📜  所有 Y 大小子数组中最大和最小元素之间的最小差异

📅  最后修改于: 2021-09-06 05:48:46             🧑  作者: Mango

给定一个大小为N的数组 arr[]和整数Y ,任务是找到大小为 Y 的所有子数组中最大和最小元素之间的所有差异的最小值。

例子:

朴素的方法:朴素的想法是遍历[0, N – Y]范围内的每个索引i,使用另一个循环从i个索引遍历到第(i + Y – 1)索引,然后计算最小和最大元素在大小为Y的子数组中,因此计算第 i迭代的最大和最小元素的差异。最后,通过检查差异,评估最小差异。

时间复杂度: O(N*Y)
辅助空间: O(1)

高效的方法:这个想法是使用讨论的方法的概念 下一个更大的元素文章以下是步骤:

  1. 构建两个数组maxarr[]minarr[] ,其中maxarr[]将存储第 i索引处的元素的下一个元素的索引, minarr[]将存储小于该元素的下一个元素的索引在第i索引处
  2. 用 0初始化堆栈以存储上述两种情况下的索引。
  3. 对于每个索引, i在 [0, N – Y]范围内,使用嵌套循环和滑动窗口方法形成两个数组submaxsubmin。这些数组将在第i次迭代中存储子数组中的最大和最小元素。
  4. 最后,计算最小差异。

下面是上述方法的实现:

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 Pathak


输出:
1

时间复杂度: O(N)
辅助空间: O(N)

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