Open In App

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy

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++ 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 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


















                        






                        























                                    



                                    




                                    




                                    


                                



















# 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# 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


















                        






                        























                                    



                                    




                                    




                                    


                                



















<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)

	

        Article Tags : 
        

            Arrays
Competitive Programming
DSA
Mathematical
Searching        


	


      

      

          
Recommended Articles

      

      

          
          
1. Minimize insertions required to make ratio of maximum and minimum of all pairs of adjacent array elements at most K

          
2. Minimize insertions to make sum of every pair of consecutive array elements at most K

          
3. Minimize cost of insertions and deletions required to make all array elements equal

          
4. Minimize deletion or insertions of Array elements such that arr[i] have frequency as its value

          
5. Maximize element at index K in an array with at most sum M and difference between adjacent elements at most 1

          
6. Minimum number of insertions in given String to remove adjacent duplicates

          
7. Minimize insertions in an array to obtain all sums upto N

          
8. Minimize insertions required to make all characters of a given string equal

          
9. Minimize insertions or deletions to make frequency of each array element equal to its value

          
10. Minimize insertions and deletions in given array A[] to make it identical to array B[]

          
11. Minimize insertions in Array to make ratio of each pair as K

          
12. Minimize insertions in Array to divide it in pairs with Bitwise XOR as X

          
13. Minimize removal or insertions required to make two strings equal

          
14. Minimize the maximum distance between adjacent points after adding K points anywhere in between

          
15. Minimize the maximum difference between adjacent elements in an array

          
16. Minimize the maximum absolute difference of adjacent elements in a circular array

          
17. Minimize maximum difference between adjacent elements possible by removing a single array element

          
18. Modify array to a permutation of consecutive numbers of longest length by at most K insertions

          
19. Minimize splits in given Array to find subsets of at most 2 elements with sum at most K

          
20. Minimize  maximum adjacent difference in a path from top-left to bottom-right

          
21. Maximum subsequence sum of at most K-distant adjacent elements

          
22. Minimize subtraction followed by increments of adjacent elements required to make all array elements equal

          
23. Minimize Array sum by replacing elements such that Relation among adjacent elements in maintained

          
24. Minimize maximum array element by splitting array elements into powers of two at most K times

          
25. Maximum height of an elevation possible such that adjacent matrix cells have a difference of at most height 1