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:
- 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.
- If getting to a building is not possible then a number of buildings of intermediate heights can be inserted in between the two buildings.
Find the minimum number of insertions done in step 2 to make it possible to go from the 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 the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int minInsertions( int H[], int n, int K)
{
int insert = 0;
for ( int i = 1; i < n; ++i) {
float diff = abs (H[i] - H[i - 1]);
if (diff <= K)
continue ;
else
insert += ceil (diff / K) - 1;
}
return insert;
}
int main()
{
int H[] = { 2, 4, 8, 16 }, K = 3;
int n = sizeof (H) / sizeof (H[0]);
cout << minInsertions(H, n, K);
return 0;
}
|
Java
class GFG{
static int minInsertions( int [] H, int n, int K)
{
int insert = 0 ;
for ( int i = 1 ; i < n; ++i) {
float diff = Math.abs(H[i] - H[i - 1 ]);
if (diff <= K)
continue ;
else
insert += Math.ceil(diff / K) - 1 ;
}
return insert;
}
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));
}
}
|
Python3
import math
def minInsertions(H, n, K):
insert = 0 ;
for i in range ( 1 , n):
diff = abs (H[i] - H[i - 1 ]);
if (diff < = K):
continue ;
else :
insert + = math.ceil(diff / K) - 1 ;
return insert;
H = [ 2 , 4 , 8 , 16 ];
K = 3 ;
n = len (H);
print (minInsertions(H, n, K));
|
C#
using System;
class GFG
{
static int minInsertions( int [] H,
int n, int K)
{
int insert
= 0;
for ( int i = 1; i < n; ++i)
{
float diff = Math.Abs(H[i] - H[i - 1]);
if (diff <= K)
continue ;
else
insert += ( int )Math.Ceiling(diff / K) - 1;
}
return insert;
}
static void Main()
{
int [] H = new int []{ 2, 4, 8, 16 };
int K = 3;
int n = H.Length;
Console.WriteLine(minInsertions(H, n, K));
}
}
|
PHP
<?php
function minInsertions( $H , $n , $K )
{
$insert = 0;
for ( $i = 1; $i < $n ; ++ $i )
{
$diff = abs ( $H [ $i ] - $H [ $i - 1]);
if ( $diff <= $K )
continue ;
else
$insert += ceil ( $diff / $K ) - 1;
}
return $insert ;
}
$H = array (2, 4, 8, 16 );
$K = 3;
$n = sizeof( $H );
echo minInsertions( $H , $n , $K );
?>
|
Javascript
<script>
function minInsertions( H, n, K)
{
var insert = 0;
for ( var i = 1; i < n; ++i) {
var diff = Math.abs(H[i] - H[i - 1]);
if (diff <= K)
continue ;
else
insert += Math.ceil(diff / K) - 1;
}
return insert;
}
var H = [ 2, 4, 8, 16 ];
var K = 3;
var n = H.length;
document.write(minInsertions(H, n, K));
</script>
|
Complexity Analysis:
- Time Complexity: O(N), since a loop runs for N times.
- Auxiliary Space: O(1), since no extra space has been taken.
Last Updated :
30 Jan, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...