Maximum elements that can be made equal with k updates
Last Updated :
30 Mar, 2023
Given an array and a value k. We have to find the maximum number of equal elements possible for the array so that we can increase the elements of the array by incrementing a total of at-most k.
Examples:
Input : array = { 2, 4, 9 }, k = 3
Output : 2
We are allowed to do at most three increments. We can make two elements 4 by increasing 2 by 2. Note that we can not make two elements 9 as converting 4 to 9 requires 5 increments.
Input : array = { 5, 5, 3, 1 }, k = 5
Output : 3
Explanation: Here 1st and 2nd elements are equal. Then we can increase 3rd element 3 upto 5. Then k becomes (k-2) = 3. Now we can’t increase 1 to 5 because k value is 3 and we need 4 for the updation. Thus equal elements possible are 3. Here we can also increase 1 to 5. Then also we have 3 because we can’t update 3 to 5.
Input : array = { 5, 5, 3, 1 }, k = 6
Output : 4
Naive Approach: In the naive approach we have an algorithm in O(n^2) time in which we check for each element how many other elements can be incremented so that they will become equal to them.
Efficient Approach: In this approach, first we will sort the array. Then we maintain two arrays. First is prefix sum array which stores the prefix sum of the array and another is maxx[] array which stores the maximum element found till every point, i.e., max[i] means maximum element from 1 to i. After storing these values in pre[] array and maxx[] array, we do the binary search from 1 to n(number of elements of the array) to calculate how many elements which can be incremented to make them equal. In the binary search, we use one function in which we determine what is the number of elements can be incremented to make them equal to a single value.
C++
#include <bits/stdc++.h>
using namespace std;
bool ElementsCalculationFunc( int pre[], int maxx[],
int x, int k, int n)
{
for ( int i = 0, j = x; j <= n; j++, i++) {
if (x * maxx[j] - (pre[j] - pre[i]) <= k)
return true ;
}
return false ;
}
void MaxNumberOfElements( int a[], int n, int k)
{
sort(a, a + n);
int pre[n + 1];
int maxx[n + 1];
for ( int i = 0; i <= n; ++i) {
pre[i] = 0;
maxx[i] = 0;
}
for ( int i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + a[i - 1];
maxx[i] = max(maxx[i - 1], a[i - 1]);
}
int l = 1, r = n, ans;
while (l < r) {
int mid = (l + r) / 2;
if (ElementsCalculationFunc(pre, maxx,
mid - 1, k, n)) {
ans = mid;
l = mid + 1;
}
else
r = mid - 1;
}
cout << ans << "\n" ;
}
int main()
{
int arr[] = { 2, 4, 9 };
int n = sizeof (arr) / sizeof (arr[0]);
int k = 3;
MaxNumberOfElements(arr, n, k);
return 0;
}
|
Java
import java.util.Arrays;
public class GFG {
static boolean ElementsCalculationFunc( int pre[],
int maxx[], int x, int k, int n)
{
for ( int i = 0 , j = x; j <= n; j++, i++) {
if (x * maxx[j] - (pre[j] - pre[i]) <= k)
return true ;
}
return false ;
}
static void MaxNumberOfElements( int a[], int n, int k)
{
Arrays.sort(a);
int []pre = new int [n + 1 ];
int []maxx = new int [n + 1 ];
for ( int i = 0 ; i <= n; ++i) {
pre[i] = 0 ;
maxx[i] = 0 ;
}
for ( int i = 1 ; i <= n; i++) {
pre[i] = pre[i - 1 ] + a[i - 1 ];
maxx[i] = Math.max(maxx[i - 1 ], a[i - 1 ]);
}
int l = 1 , r = n, ans= 0 ;
while (l < r) {
int mid = (l + r) / 2 ;
if (ElementsCalculationFunc(pre, maxx,
mid - 1 , k, n))
{
ans = mid;
l = mid + 1 ;
}
else
r = mid - 1 ;
}
System.out.print(( int )ans + "\n" );
}
public static void main(String args[]) {
int arr[] = { 2 , 4 , 9 };
int n = arr.length;
int k = 3 ;
MaxNumberOfElements(arr, n, k);
}
}
|
Python3
def ElementsCalculationFunc(pre, maxx,
x, k, n):
i = 0
j = x
while j < = n:
if (x * maxx[j] - (pre[j] - pre[i]) < = k):
return True
i + = 1
j + = 1
return False
def MaxNumberOfElements( a, n, k):
a.sort()
pre = [ 0 ] * (n + 1 )
maxx = [ 0 ] * (n + 1 )
for i in range (n + 1 ):
pre[i] = 0
maxx[i] = 0
for i in range ( 1 , n + 1 ):
pre[i] = pre[i - 1 ] + a[i - 1 ]
maxx[i] = max (maxx[i - 1 ], a[i - 1 ])
l = 1
r = n
while (l < r) :
mid = (l + r) / / 2
if (ElementsCalculationFunc(pre, maxx,
mid - 1 , k, n)):
ans = mid
l = mid + 1
else :
r = mid - 1
print (ans)
if __name__ = = "__main__" :
arr = [ 2 , 4 , 9 ]
n = len (arr)
k = 3
MaxNumberOfElements(arr, n, k)
|
C#
using System;
class GFG {
static bool ElementsCalculationFunc( int []pre,
int []maxx, int x, int k, int n)
{
for ( int i = 0, j = x; j <= n; j++, i++) {
if (x * maxx[j] - (pre[j] - pre[i]) <= k)
return true ;
}
return false ;
}
static void MaxNumberOfElements( int []a, int n, int k)
{
Array.Sort(a);
int []pre = new int [n + 1];
int []maxx = new int [n + 1];
for ( int i = 0; i <= n; ++i) {
pre[i] = 0;
maxx[i] = 0;
}
for ( int i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + a[i - 1];
maxx[i] = Math.Max(maxx[i - 1], a[i - 1]);
}
int l = 1, r = n, ans=0;
while (l < r) {
int mid = (l + r) / 2;
if (ElementsCalculationFunc(pre, maxx,
mid - 1, k, n))
{
ans = mid;
l = mid + 1;
}
else
r = mid - 1;
}
Console.Write (( int )ans + "\n" );
}
public static void Main()
{
int []arr = { 2, 4, 9 };
int n = arr.Length;
int k = 3;
MaxNumberOfElements(arr, n, k);
}
}
|
PHP
<?php
function ElementsCalculationFunc( $pre , $maxx , $x , $k , $n )
{
for ( $i = 0, $j = $x ; $j <= $n ; $j ++, $i ++) {
if ( $x * $maxx [ $j ] - ( $pre [ $j ] - $pre [ $i ]) <= $k )
return true;
}
return false;
}
function MaxNumberOfElements( $a , $n , $k )
{
sort( $a );
$pre [ $n + 1]= array ();
$maxx [ $n + 1]= array ();
for ( $i = 0; $i <= $n ; ++ $i ) {
$pre [ $i ] = 0;
$maxx [ $i ] = 0;
}
for ( $i = 1; $i <= $n ; $i ++) {
$pre [ $i ] = $pre [ $i - 1] + $a [ $i - 1];
$maxx [ $i ] = max( $maxx [ $i - 1], $a [ $i - 1]);
}
$l = 1;
$r = $n ;
$ans ;
while ( $l < $r ) {
$mid = ( $l + $r ) / 2;
if (ElementsCalculationFunc( $pre , $maxx ,
$mid - 1, $k , $n )) {
$ans = $mid ;
$l = $mid + 1;
}
else
$r = $mid - 1;
}
echo $ans , "\n" ;
}
$arr = array (2, 4, 9 );
$n = sizeof( $arr ) / sizeof( $arr [0]);
$k = 3;
MaxNumberOfElements( $arr , $n , $k );
#This code is contributed by akt_mit.
?>
|
Javascript
<script>
function ElementsCalculationFunc(pre, maxx, x, k, n)
{
for (let i = 0, j = x; j <= n; j++, i++)
{
if (x * maxx[j] - (pre[j] - pre[i]) <= k)
return true ;
}
return false ;
}
function MaxNumberOfElements(a, n, k)
{
a.sort( function (a,b){ return a-b;});
let pre = new Array(n + 1);
let maxx = new Array(n + 1);
for (let i = 0; i <= n; ++i)
{
pre[i] = 0;
maxx[i] = 0;
}
for (let i = 1; i <= n; i++)
{
pre[i] = pre[i - 1] + a[i - 1];
maxx[i] = Math.max(maxx[i - 1], a[i - 1]);
}
let l = 1, r = n, ans=0;
while (l < r)
{
let mid = Math.floor((l + r) / 2);
if (ElementsCalculationFunc(pre, maxx,
mid - 1, k, n))
{
ans = mid;
l = mid + 1;
}
else
r = mid - 1;
}
document.write(ans + "\n" );
}
let arr = [2, 4, 9 ];
let n = arr.length;
let k = 3;
MaxNumberOfElements(arr, n, k);
</script>
|
Time Complexity :O(n log(n))
Space Complexity : O(n)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...