Given an array arr[] having N integers, and an integer K, the task is to find an array such that it contains a single elements maximum number of times possible after K replacements within array elements.
Examples:
Input: N = 7, arr[] = {1, 2, 1, 5, 1, 6, 7}, K = 3
Output: {1, 1, 1, 1, 1, 1, 7}
Explanation: We can replace element on index 1, 3, and 5 with 1, i.e. A[1] = A[0], A[3] = A[0] and A[5] = A[0]Input: N = 6, arr[] = {2, 2, 2, 5, 1, 6 }, K = 3
Output: {2, 2, 2, 2, 2, 2 }
Approach: The approach to solve this problem is based on following idea:
- If we dont do any replacement, and if there are duplicates present in the array, then there will be an element present already occurring maximum number of times in the array.
- Now when K replacements are allowed, we can simply try to change replace elements not equal to maximum occurring element with maximum occurring element K times, to get the desired array.
Following is the algorithm to implement above discussed approach:
- Create a hashmap to store the frequency of every distinct element.
- Find the maximum occurring element in the array.
- Then assign every element value of maximum occurring element.
- Make sure to take care of frequency before assigning the element and after assigning the element.
- For that first decrease the frequency of the current element and after assigning it the maximum occurring value increase its value in the hashmap.
Below is the implementation of the above approach:
// C++ code for the above discussed approach #include <bits/stdc++.h> using namespace std;
// Function to maximizeTheElements vector< int > maximizeTheElements(
int N, vector< int > arr, int K)
{ // Map to store the frequency
// of the elements
unordered_map< int , int > mp;
int max_freq = 0, max_element = -1;
for ( auto x : arr) {
mp[x]++;
// Getting max_element
if (mp[x] > max_freq) {
max_freq = mp[x];
max_element = x;
}
}
for ( int i = 0; i < N && K > 0; i++) {
// If the element is not equal
// to the max_element
if (arr[i] != max_element) {
// Decrease its frequency from the map
mp[arr[i]] -= 1;
// Assign the max frequency element
arr[i] = max_element;
// Increase its frequency in the map
mp[arr[i]] += 1;
// Decrease the operation by 1
K -= 1;
}
}
// Return the modified array
return arr;
} // Driver Function int main()
{ int N = 7;
vector< int > arr = { 1, 2, 1, 5, 1, 6, 7 };
int K = 3;
// Function call
vector< int > res = maximizeTheElements(N, arr, K);
for ( auto x : res) {
cout << x << " " ;
}
cout << endl;
return 0;
} |
// Java code for the above discussed approach import java.util.*;
class GFG {
// Function to maximizeTheElements
static int [] maximizeTheElements(
int N, int arr[], int K)
{
// Map to store the frequency
// of the elements
HashMap<Integer, Integer> m = new HashMap<Integer, Integer>();
int max_freq = 0 , max_element = - 1 ;
for ( int i = 0 ; i < arr.length; i++){
if (m.containsKey(arr[i])){
m.put(arr[i], m.get(arr[i]) + 1 );
}
else {
m.put(arr[i], 1 );
}
// Getting max_element
if (m.get(arr[i]) > max_freq) {
max_freq = m.get(arr[i]);
max_element = arr[i];
}
}
for ( int i = 0 ; i < N; i++) {
if (K <= 0 ) break ;
// If the element is not equal
// to the max_element
if (arr[i] != max_element) {
// Decrease its frequency from the map
m.put(arr[i], m.get(arr[i]) - 1 );
// Assign the max frequency element
arr[i] = max_element;
// Increase its frequency in the map
m.put(arr[i], m.get(arr[i]) + 1 );
// Decrease the operation by 1
K -= 1 ;
}
}
// Return the modified array
return arr;
}
// Driver Function
public static void main (String[] args) {
int N = 7 ;
int arr[] = { 1 , 2 , 1 , 5 , 1 , 6 , 7 };
int K = 3 ;
// Function call
int res[] = maximizeTheElements(N, arr, K);
for ( int x : res) {
System.out.print(x + " " );
}
}
} // This code is contributed by hrithikgarg03188. |
# Python3 code for the above discussed approach # Function to maximizeTheElements def maximizeTheElements(N, arr, K):
# Map to store the frequency
# of the elements
mp = {}
max_freq, max_element = 0 , - 1
for x in arr:
mp[x] = mp[x] + 1 if x in mp else 1
# Getting max_element
if (mp[x] > max_freq):
max_freq = mp[x]
max_element = x
for i in range ( 0 , N):
if K < = 0 :
break
# If the element is not equal
# to the max_element
if (arr[i] ! = max_element):
# Decrease its frequency from the map
mp[arr[i]] - = 1
# Assign the max frequency element
arr[i] = max_element
# Increase its frequency in the map
mp[arr[i]] + = 1
# Decrease the operation by 1
K - = 1
# Return the modified array
return arr
# Driver Function if __name__ = = "__main__" :
N = 7
arr = [ 1 , 2 , 1 , 5 , 1 , 6 , 7 ]
K = 3
# Function call
res = maximizeTheElements(N, arr, K)
for x in res:
print (x, end = " " )
# This code is contributed by rakeshsahni
|
// C# code for the above discussed approach using System;
using System.Collections.Generic;
public class GFG
{ // Function to maximizeTheElements
static int [] maximizeTheElements( int N, int [] arr,
int K)
{
// Map to store the frequency
// of the elements
var m = new Dictionary< int , int >();
int max_freq = 0, max_element = -1;
for ( int i = 0; i < arr.Length; i++) {
if (m.ContainsKey(arr[i])) {
m[arr[i]] += 1;
}
else {
m[arr[i]] = 1;
}
// Getting max_element
if (m[arr[i]] > max_freq) {
max_freq = m[arr[i]];
max_element = arr[i];
}
}
for ( int i = 0; i < N; i++) {
if (K <= 0)
break ;
// If the element is not equal
// to the max_element
if (arr[i] != max_element) {
// Decrease its frequency from the map
m[arr[i]] -= 1;
// Assign the max frequency element
arr[i] = max_element;
// Increase its frequency in the map
m[arr[i]] += 1;
// Decrease the operation by 1
K -= 1;
}
}
// Return the modified array
return arr;
}
// Driver Code
public static void Main( string [] args)
{
int N = 7;
int [] arr = { 1, 2, 1, 5, 1, 6, 7 };
int K = 3;
// Function call
int [] res = maximizeTheElements(N, arr, K);
for ( int i = 0; i < res.Length; i++) {
Console.Write(res[i] + " " );
}
}
} // This code is contributed by phasing17 |
<script> // JavaScript code for the above approach
// Function to maximizeTheElements
function maximizeTheElements(
N, arr, K) {
// Map to store the frequency
// of the elements
let mp = new Map();
let max_freq = 0, max_element = -1;
for (let x of arr) {
if (!mp.has(x)) {
mp.set(x, 1)
}
else {
mp.set(x, mp.get(x) + 1)
}
// Getting max_element
if (mp.get(x) > max_freq) {
max_freq = mp.get(x);
max_element = x;
}
}
for (let i = 0; i < N && K > 0; i++) {
// If the element is not equal
// to the max_element
if (arr[i] != max_element) {
// Decrease its frequency from the map
mp.set(arr[i], mp.get(arr[i]) - 1)
// Assign the max frequency element
arr[i] = max_element;
// Increase its frequency in the map
mp.set(arr[i], mp.get(arr[i]) + 1)
// Decrease the operation by 1
K -= 1;
}
}
// Return the modified array
return arr;
}
// Driver Function
let N = 7;
let arr = [1, 2, 1, 5, 1, 6, 7];
let K = 3;
// Function call
let res = maximizeTheElements(N, arr, K);
for (let x of res) {
document.write(x + " " );
}
// This code is contributed by Potta Lokesh
</script>
|
1 1 1 1 1 1 7
Time Complexity: O(N)
Auxiliary Space: O(N)