Minimum array insertions required to make consecutive difference <= K

Given an integer array H which represents heights of buildings and an integer K. The task is to reach the last building from the first with the following rules:

  1. Getting to a building of height Hj from a building of height Hi is only possible if |Hi – Hj| <= K and the building appears one after another in the array.
  2. If getting to a building is not possible then a number of buildings of intermediate heights can be inserted in between the two building.

Find the minimum number of insertions done in step 2 to make it possible to go from first building to the last.

Examples:



Input: H[] = {2, 4, 8, 16}, K = 3
Output: 3
Add 1 building of height 5 between buildings of height 4 and 8.
And add 2 buildings of heights 11 and 14 respectively between buildings of height 8 and 16.

Input: H[] = {5, 55, 100, 1000}, K = 10
Output: 97

Approach:

  • Run a loop from 1 to n-1 and check whether abs(H[i] - H[i-1]) <= K.
  • If the above condition is true then skip to the next iteration of the loop.
  • If the condition is false, then the insertions required will be equal to ceil(diff / K) - 1 where diff = abs(H[i] - H[i-1])
  • Print the total insertions in the end.

Below is the implementation of above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP implementation of above approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to return minimum
// number of insertions required
int minInsertions(int H[], int n, int K)
{
    // Initialize insertions to 0
    int inser = 0;
  
    for (int i = 1; i < n; ++i) {
        float diff = abs(H[i] - H[i - 1]);
  
        if (diff <= K)
            continue;
        else
            inser += ceil(diff / K) - 1;
    }
  
    // return total insertions
    return inser;
}
  
// Driver program
int main()
{
    int H[] = { 2, 4, 8, 16 }, K = 3;
    int n = sizeof(H) / sizeof(H[0]);
    cout << minInsertions(H, n, K);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of above approach
  
class GFG{
// Function to return minimum
// number of insertions required
static int minInsertions(int[] H, int n, int K)
{
    // Initialize insertions to 0
    int inser = 0;
  
    for (int i = 1; i < n; ++i) {
        float diff = Math.abs(H[i] - H[i - 1]);
  
        if (diff <= K)
            continue;
        else
            inser += Math.ceil(diff / K) - 1;
    }
  
    // return total insertions
    return inser;
}
  
// Driver program
public static void main(String[] args)
{
    int[] H = new int[]{ 2, 4, 8, 16 };
    int K = 3;
    int n = H.length;
    System.out.println(minInsertions(H, n, K));
}
}
// This code is contributed by mits

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of above approach
import math
  
# Function to return minimum
# number of insertions required
def minInsertions(H, n, K):
  
    # Initialize insertions to 0
    inser = 0;
  
    for i in range(1, n):
        diff = abs(H[i] - H[i - 1]);
  
        if (diff <= K):
            continue;
        else:
            inser += math.ceil(diff / K) - 1;
  
    # return total insertions
    return inser;
  
# Driver Code
H = [2, 4, 8, 16 ];
K = 3;
n = len(H);
print(minInsertions(H, n, K));
  
# This code is contributed 
# by mits

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of above approach
using System;
  
class GFG
{
// Function to return minimum
// number of insertions required
static int minInsertions(int[] H, 
                         int n, int K)
{
    // Initialize insertions to 0
    int inser = 0;
  
    for (int i = 1; i < n; ++i)
    {
        float diff = Math.Abs(H[i] - H[i - 1]);
  
        if (diff <= K)
            continue;
        else
            inser += (int)Math.Ceiling(diff / K) - 1;
    }
  
    // return total insertions
    return inser;
}
  
// Driver Code
static void Main()
{
    int[] H = new int[]{ 2, 4, 8, 16 };
    int K = 3;
    int n = H.Length;
    Console.WriteLine(minInsertions(H, n, K));
}
}
  
// This code is contributed by mits

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP implementation of above approach
  
// Function to return minimum
// number of insertions required
function minInsertions($H, $n, $K)
{
    // Initialize insertions to 0
    $inser = 0;
  
    for ($i = 1; $i < $n; ++$i)
    {
        $diff = abs($H[$i] - $H[$i - 1]);
  
        if ($diff <= $K)
            continue;
        else
            $inser += ceil($diff / $K) - 1;
    }
  
    // return total insertions
    return $inser;
}
  
// Driver Code
$H = array(2, 4, 8, 16 );
$K = 3;
$n = sizeof($H);
echo minInsertions($H, $n, $K);
  
// This code is contributed 
// by Akanksha Rai(Abby_akku)
?>

chevron_right


Output:

3


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : Mithun Kumar, Akanksha_Rai



Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.