Minimize the maximum difference of adjacent elements after at most K insertions

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: 2 
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: 3 
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

Javascript

<script>

// javascript Program to find the minimum of maximum
// differerence between adjacent elements
// after at most K insertions

function minMaxDiff(arr, n, k)
{
    var max_adj_dif = -1000000000;
    // Calculate the maximum
    // adjacent difference
    for (var 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
    var best = 1;
    var worst = max_adj_dif;
    var mid, required;

    while (best < worst) {

        mid = (best + worst) / 2;

        // To store the no of insertions
        // required for respective
        // values of mid
        required = 0;

        for (var i = 0; i < n - 1; i++) {

            required += parseInt((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
var arr = [ 3, 12, 25, 50 ];
var n = arr.length;
var k = 7;
document.write( minMaxDiff(arr, n, k));

</script>

Output:

5

Time Complexity: O(n * log n)

Auxiliary Space: O(1)