Skip to content
Related Articles

Related Articles

Minimize the maximum difference of adjacent elements after at most K insertions
  • Difficulty Level : Medium
  • Last Updated : 17 Aug, 2020

Given an array of N elements, the task is to minimize the maximum difference of adjacent elements by inserting at most K elements in the array.
Examples: 
 

Input: arr = [2, 6, 8] K = 1 
Output:
Explanation: 
After insertion of 4 in between 2 and 6, the array becomes [2, 4, 6, 8]. In this case the maximum difference between any adjacent element is 2, which is the minimum that can be.
Input: arr = [3, 12] K = 2 
Output:
Explanation: 
After insertion of 6 and 9 in between 3 and 12, the array becomes [3, 6, 9, 12]. In this case the maximum difference between any adjacent element is 3, which is the minimum that can be. 
 

 

Approach: In order to solve this problem, we are using the following Binary Search based approach:
 

  1. Find the maximum difference between any two adjacent element in the array and store it in a variable, say worst.
  2. Search from best(1 initially) to worst and for every mid value find the number of insertions required.
  3. Whenever the number of insertions is greater than K for a particular value of mid, search between [mid + 1, worst], that is the higher half. Otherwise search between [best, mid-1], that is the lower half to check if the maximum difference can be further minimized with at most K insertions.
  4. The final worst value after termination of the loop gives the answer.

Below code is the implementation of the above approach:
 

C++




// C++ Program to find the minimum of maximum
// differerence between adjacent elements
// after at most K insertions
 
#include <bits/stdc++.h>
using namespace std;
 
int minMaxDiff(int arr[], int n, int k)
{
    int max_adj_dif = INT_MIN;
    // Calculate the maximum
    // adjacent difference
    for (int i = 0; i < n - 1; i++)
        max_adj_dif
            = max(max_adj_dif,
                  abs(arr[i] - arr[i + 1]));
 
    // If the maximum adjacent
    // difference is already zero
    if (max_adj_dif == 0)
        return 0;
 
    // best and worst specifies
    // range of the maximum
    // adjacent difference
    int best = 1;
    int worst = max_adj_dif;
    int mid, required;
 
    while (best < worst) {
 
        mid = (best + worst) / 2;
 
        // To store the no of insertions
        // required for respective
        // values of mid
        required = 0;
 
        for (int i = 0; i < n - 1; i++) {
 
            required += (abs(arr[i]
                             - arr[i + 1])
                         - 1)
                        / mid;
        }
 
        // If the number of insertions
        // required exceeds K
        if (required > k)
            best = mid + 1;
 
        // Otherwise
        else
            worst = mid;
    }
 
    return worst;
}
 
// Driver code
int main()
{
    int arr[] = { 3, 12, 25, 50 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 7;
 
    cout << minMaxDiff(arr, n, k);
    return 0;
}

Java




// Java program to find the minimum
// of maximum difference between
// adjacent elements after at most
// K insertions
import java.util.*;
 
class GFG{
     
static int minMaxDiff(int arr[], int n, int k)
{
    int max_adj_dif = Integer.MIN_VALUE;
     
    // Calculate the maximum
    // adjacent difference
    for(int i = 0; i < n - 1; i++)
        max_adj_dif = Math.max(max_adj_dif,
                      Math.abs(arr[i] -
                               arr[i + 1]));
 
    // If the maximum adjacent
    // difference is already zero
    if (max_adj_dif == 0)
        return 0;
 
    // best and worst specifies
    // range of the maximum
    // adjacent difference
    int best = 1;
    int worst = max_adj_dif;
    int mid, required;
 
    while (best < worst)
    {
        mid = (best + worst) / 2;
 
        // To store the no of insertions
        // required for respective
        // values of mid
        required = 0;
 
        for(int i = 0; i < n - 1; i++)
        {
            required += (Math.abs(arr[i] -
                                  arr[i + 1]) -
                                     1) / mid;
        }
 
        // If the number of insertions
        // required exceeds K
        if (required > k)
            best = mid + 1;
 
        // Otherwise
        else
            worst = mid;
    }
    return worst;
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 3, 12, 25, 50 };
    int n = arr.length;
    int k = 7;
 
    System.out.println(minMaxDiff(arr, n, k));
}
}
 
// This code is contributed by ANKITKUMAR34

Python 3




# Python3 program to find the minimum
# of maximum difference between
# adjacent elements after at most
# K insertions
def minMaxDiff(arr, n, k):
 
    max_adj_dif = float('-inf');
     
    # Calculate the maximum
    # adjacent difference
    for i in range(n - 1):
        max_adj_dif = max(max_adj_dif,
                          abs(arr[i] -
                              arr[i + 1]));
 
    # If the maximum adjacent
    # difference is already zero
    if (max_adj_dif == 0):
        return 0;
 
    # best and worst specifies
    # range of the maximum
    # adjacent difference
    best = 1;
    worst = max_adj_dif;
     
    while (best < worst):
        mid = (best + worst) // 2;
 
        # To store the no of insertions
        # required for respective
        # values of mid
        required = 0
 
        for i in range(n - 1):
            required += (abs(arr[i] -
                             arr[i + 1]) - 1) // mid
             
        # If the number of insertions
        # required exceeds K
        if (required > k):
            best = mid + 1;
 
        # Otherwise
        else:
            worst = mid
 
    return worst
 
# Driver code
arr = [ 3, 12, 25, 50 ]
n = len(arr)
k = 7
 
print(minMaxDiff(arr, n, k))
 
# This code is contributed by ANKITKUMAR34

C#




// C# program to find the minimum
// of maximum difference between
// adjacent elements after at most
// K insertions
using System;
class GFG{
     
static int minMaxDiff(int []arr, int n, int k)
{
    int max_adj_dif = int.MinValue;
     
    // Calculate the maximum
    // adjacent difference
    for(int i = 0; i < n - 1; i++)
        max_adj_dif = Math.Max(max_adj_dif,
                      Math.Abs(arr[i] -
                               arr[i + 1]));
 
    // If the maximum adjacent
    // difference is already zero
    if (max_adj_dif == 0)
        return 0;
 
    // best and worst specifies
    // range of the maximum
    // adjacent difference
    int best = 1;
    int worst = max_adj_dif;
    int mid, required;
 
    while (best < worst)
    {
        mid = (best + worst) / 2;
 
        // To store the no of insertions
        // required for respective
        // values of mid
        required = 0;
 
        for(int i = 0; i < n - 1; i++)
        {
            required += (Math.Abs(arr[i] -
                                  arr[i + 1]) -
                                      1) / mid;
        }
 
        // If the number of insertions
        // required exceeds K
        if (required > k)
            best = mid + 1;
 
        // Otherwise
        else
            worst = mid;
    }
    return worst;
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { 3, 12, 25, 50 };
    int n = arr.Length;
    int k = 7;
 
    Console.WriteLine(minMaxDiff(arr, n, k));
}
}
 
// This code is contributed by Princi Singh
Output: 
5


 

competitive-programming-img




My Personal Notes arrow_drop_up
Recommended Articles
Page :