Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Minimize difference between maximum and minimum array elements by removing a K-length subarray

  • Difficulty Level : Hard
  • Last Updated : 25 May, 2021

Given an array arr[] consisting of N integers and an integer K, the task is to find the minimum difference between the maximum and minimum element present in the array after removing any subarray of size K.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {4, 5, 8, 9, 1, 2}, K = 2
Output: 4
Explanation: Remove the subarray {8, 9}. The minimum difference between maximum and minimum array elements becomes (5 – 1) = 4.



Input: arr[] = {1, 2, 2}, K = 1
Output: 0
Explanation: Remove subarray {1}. The minimum difference between maximum and minimum array elements becomes (2 – 2) = 0.

 

Naive Approach: The simplest approach is to remove all possible subarrays of size K one by one and calculate the difference between maximum and minimum among the remaining elements. Finally, print the minimum difference obtained.
Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized by storing maximum and minimum prefixes upto any index and storing the maximum and minimum suffies starting from any index. Once the above four values are calculated, find the maximum and minimum array elements after removing a K-length subarray in constant computational complexity. 

Follow the steps below to solve the problem:

  • Initialize arrays maxSufix[] and minSuffix[]. such that ith element of maxSuffix[] and minSuffix[] array denotes the maximum and minimum elements respectively present at the right of the ith index.
  • Initialize two variables, say maxPrefix and minPrefix, to store the maximum and minimum elements present in the prefix subarray.
  • Traverse the array over the indices [1, N] and check if i + K <= N or not. If found to be true, then perform the following steps:
    • The maximum value present in the array after removing a subarray of size K starting from ith index is max(maxSuffix[i + k], maxPrefix).
    • The minimum value present in the array after removing a subarray of size K starting from ith index is min(minSuffix[i + k], minPrefix).
    • Update minDiff to min( minDiff, maximum – minimum), to store the minimum difference.
  • Print minDiff as the required answer.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to minimize difference
// between maximum and minimum array
// elements by removing a K-length subarray
void minimiseDifference(vector<int>& arr, int K)
{
    // Size of array
    int N = arr.size();
 
    // Stores the maximum and minimum
    // in the suffix subarray [i .. N-1]
    int maxSuffix[N + 1], minSuffix[N + 1];
 
    maxSuffix[N] = -1e9;
    minSuffix[N] = 1e9;
    maxSuffix[N - 1] = arr[N - 1];
    minSuffix[N - 1] = arr[N - 1];
 
    // Constructing the maxSuffix and
    // minSuffix arrays
 
    // Traverse the array
    for (int i = N - 2; i >= 0; --i) {
 
        maxSuffix[i] = max(
maxSuffix[i + 1],
 arr[i]);
        minSuffix[i] = min(
minSuffix[i + 1],
 arr[i]);
    }
 
    // Stores the maximum and minimum
    // in the prefix subarray [0 .. i-1]
    int maxPrefix = arr[0];
    int minPrefix = arr[0];
 
    // Store the minimum difference
    int minDiff = maxSuffix[K] - minSuffix[K];
 
    // Traverse the array
    for (int i = 1; i < N; ++i) {
 
        // If the suffix doesn't exceed
        // the end of the array
        if (i + K <= N) {
 
            // Store the maximum element
            // in array after removing
            // subarray of size K
            int maximum = max(maxSuffix[i + K], maxPrefix);
 
            // Stores the maximum element
            // in array after removing
            // subarray of size K
            int minimum = min(minSuffix[i + K], minPrefix);
 
            // Update minimum difference
            minDiff = min(minDiff, maximum - minimum);
        }
 
        // Updating the maxPrefix and
        // minPrefix with current element
        maxPrefix = max(maxPrefix, arr[i]);
        minPrefix = min(minPrefix, arr[i]);
    }
 
    // Print the minimum difference
    cout << minDiff << "\n";
}
 
// Driver Code
int main()
{
    vector<int> arr = { 4, 5, 8, 9, 1, 2 };
    int K = 2;
    minimiseDifference(arr, K);
 
    return 0;
}

Java




// Java program for the above approach
import java.util.*;
class GFG
{
 
  // Function to minimize difference
  // between maximum and minimum array
  // elements by removing a K-length subarray
  static void minimiseDifference(int[] arr, int K)
  {
    // Size of array
    int N = arr.length;
 
    // Stores the maximum and minimum
    // in the suffix subarray [i .. N-1]
    int[] maxSuffix = new int[N + 1];
    int[] minSuffix = new int[N + 1];
 
    maxSuffix[N] = -1000000000;
    minSuffix[N] = 1000000000;
    maxSuffix[N - 1] = arr[N - 1];
    minSuffix[N - 1] = arr[N - 1];
 
    // Constructing the maxSuffix and
    // minSuffix arrays
 
    // Traverse the array
    for (int i = N - 2; i >= 0; --i) {
 
      maxSuffix[i]
        = Math.max(maxSuffix[i + 1], arr[i]);
      minSuffix[i]
        = Math.min(minSuffix[i + 1], arr[i]);
    }
 
    // Stores the maximum and minimum
    // in the prefix subarray [0 .. i-1]
    int maxPrefix = arr[0];
    int minPrefix = arr[0];
 
    // Store the minimum difference
    int minDiff = maxSuffix[K] - minSuffix[K];
 
    // Traverse the array
    for (int i = 1; i < N; ++i) {
 
      // If the suffix doesn't exceed
      // the end of the array
      if (i + K <= N) {
 
        // Store the maximum element
        // in array after removing
        // subarray of size K
        int maximum
          = Math.max(maxSuffix[i + K], maxPrefix);
 
        // Stores the maximum element
        // in array after removing
        // subarray of size K
        int minimum
          = Math.min(minSuffix[i + K], minPrefix);
 
        // Update minimum difference
        minDiff
          = Math.min(minDiff, maximum - minimum);
      }
 
      // Updating the maxPrefix and
      // minPrefix with current element
      maxPrefix = Math.max(maxPrefix, arr[i]);
      minPrefix = Math.min(minPrefix, arr[i]);
    }
 
    // Print the minimum difference
    System.out.print(minDiff);
  }
 
  // Driver Code
  public static void main(String[] args)
  {
    int[] arr = { 4, 5, 8, 9, 1, 2 };
    int K = 2;
    minimiseDifference(arr, K);
  }
}
 
// This code is contributed by susmitakundugoaldanga.

Python3




# Python 3 program for the above approach
 
# Function to minimize difference
# between maximum and minimum array
# elements by removing a K-length subarray
def minimiseDifference(arr, K):
   
    # Size of array
    N = len(arr)
 
    # Stores the maximum and minimum
    # in the suffix subarray [i .. N-1]
    maxSuffix = [0 for i in range(N + 1)]
    minSuffix = [0 for i in range(N + 1)]
 
    maxSuffix[N] = -1e9
    minSuffix[N] = 1e9
    maxSuffix[N - 1] = arr[N - 1]
    minSuffix[N - 1] = arr[N - 1]
 
    # Constructing the maxSuffix and
    # minSuffix arrays
 
    # Traverse the array
    i = N - 2
    while(i >= 0):
        maxSuffix[i] = max(maxSuffix[i + 1],arr[i])
        minSuffix[i] = min(minSuffix[i + 1], arr[i])
        i -= 1
 
    # Stores the maximum and minimum
    # in the prefix subarray [0 .. i-1]
    maxPrefix = arr[0]
    minPrefix = arr[0]
 
    # Store the minimum difference
    minDiff = maxSuffix[K] - minSuffix[K]
 
    # Traverse the array
    for i in range(1, N):
       
        # If the suffix doesn't exceed
        # the end of the array
        if (i + K <= N):
           
            # Store the maximum element
            # in array after removing
            # subarray of size K
            maximum = max(maxSuffix[i + K], maxPrefix)
 
            # Stores the maximum element
            # in array after removing
            # subarray of size K
            minimum = min(minSuffix[i + K], minPrefix)
 
            # Update minimum difference
            minDiff = min(minDiff, maximum - minimum)
 
        # Updating the maxPrefix and
        # minPrefix with current element
        maxPrefix = max(maxPrefix, arr[i])
        minPrefix = min(minPrefix, arr[i])
 
    # Print the minimum difference
    print(minDiff)
 
# Driver Code
if __name__ == '__main__':
    arr =  [4, 5, 8, 9, 1, 2]
    K = 2
    minimiseDifference(arr, K)
     
    # This code is contributed by SURENDRA_GANGWAR.

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
class GFg {
 
  // Function to minimize difference
  // between maximum and minimum array
  // elements by removing a K-length subarray
  static void minimiseDifference(List<int> arr, int K)
  {
    // Size of array
    int N = arr.Count;
 
    // Stores the maximum and minimum
    // in the suffix subarray [i .. N-1]
    int[] maxSuffix = new int[N + 1];
    int[] minSuffix = new int[N + 1];
 
    maxSuffix[N] = -1000000000;
    minSuffix[N] = 1000000000;
    maxSuffix[N - 1] = arr[N - 1];
    minSuffix[N - 1] = arr[N - 1];
 
    // Constructing the maxSuffix and
    // minSuffix arrays
 
    // Traverse the array
    for (int i = N - 2; i >= 0; --i) {
 
      maxSuffix[i]
        = Math.Max(maxSuffix[i + 1], arr[i]);
      minSuffix[i]
        = Math.Min(minSuffix[i + 1], arr[i]);
    }
 
    // Stores the maximum and minimum
    // in the prefix subarray [0 .. i-1]
    int maxPrefix = arr[0];
    int minPrefix = arr[0];
 
    // Store the minimum difference
    int minDiff = maxSuffix[K] - minSuffix[K];
 
    // Traverse the array
    for (int i = 1; i < N; ++i) {
 
      // If the suffix doesn't exceed
      // the end of the array
      if (i + K <= N) {
 
        // Store the maximum element
        // in array after removing
        // subarray of size K
        int maximum
          = Math.Max(maxSuffix[i + K], maxPrefix);
 
        // Stores the maximum element
        // in array after removing
        // subarray of size K
        int minimum
          = Math.Min(minSuffix[i + K], minPrefix);
 
        // Update minimum difference
        minDiff
          = Math.Min(minDiff, maximum - minimum);
      }
 
      // Updating the maxPrefix and
      // minPrefix with current element
      maxPrefix = Math.Max(maxPrefix, arr[i]);
      minPrefix = Math.Min(minPrefix, arr[i]);
    }
 
    // Print the minimum difference
    Console.WriteLine(minDiff);
  }
 
  // Driver Code
  public static void Main()
  {
    List<int> arr
      = new List<int>() { 4, 5, 8, 9, 1, 2 };
    int K = 2;
    minimiseDifference(arr, K);
  }
}
 
// This code is contributed by chitranayal.

Javascript




<script>
 
// JavaScript  program for the above approach
 
// Function to minimize difference
// between maximum and minimum array
// elements by removing a K-length subarray
function minimiseDifference(arr, K)
{
    // Size of array
    var N = arr.length;
 
    // Stores the maximum and minimum
    // in the suffix subarray [i .. N-1]
    var maxSuffix = new Array(N + 1);
    var minSuffix = new Array(N + 1);
 
    maxSuffix[N] = -1e9;
    minSuffix[N] = 1e9;
    maxSuffix[N - 1] = arr[N - 1];
    minSuffix[N - 1] = arr[N - 1];
 
    // Constructing the maxSuffix and
    // minSuffix arrays
 
    // Traverse the array
    for (var i = N - 2; i >= 0; --i) {
 
        maxSuffix[i] = Math.max(maxSuffix[i + 1], arr[i]);
        minSuffix[i] = Math.min(minSuffix[i + 1], arr[i]);
    }
 
    // Stores the maximum and minimum
    // in the prefix subarray [0 .. i-1]
    var maxPrefix = arr[0];
    var minPrefix = arr[0];
 
    // Store the minimum difference
    var minDiff = maxSuffix[K] - minSuffix[K];
 
    // Traverse the array
    for (var i = 1; i < N; ++i) {
 
        // If the suffix doesn't exceed
        // the end of the array
        if (i + K <= N) {
 
            // Store the maximum element
            // in array after removing
            // subarray of size K
            var maximum =
            Math.max(maxSuffix[i + K], maxPrefix);
 
            // Stores the maximum element
            // in array after removing
            // subarray of size K
            var minimum =
            Math.min(minSuffix[i + K], minPrefix);
 
            // Update minimum difference
            minDiff =
            Math.min(minDiff, maximum - minimum);
        }
 
        // Updating the maxPrefix and
        // minPrefix with current element
        maxPrefix = Math.max(maxPrefix, arr[i]);
        minPrefix = Math.min(minPrefix, arr[i]);
    }
 
    // Print the minimum difference
   document.write( minDiff + "<br>");
}
 
 
var arr = [ 4, 5, 8, 9, 1, 2 ];
var K = 2;
minimiseDifference(arr, K);
 
// This code is contributed by SoumikMondal
 
</script>

 
 

Output
4

Time Complexity: O(N)
Auxiliary Space: O(N) 




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!