Given two arrays a[] and b[] of length N and an integer K (1 ≤ K ≤ N). All the integers in array a[] lie within the range [1, K]. ith value in array b[] denotes the cost of replacing a[i] with any number in the range [1, N]. The task is to find the minimum cost to replace the elements of array a[] to turn it into a permutation of 1 to N.
Note: A permutation of 1 to N contains all the values from 1 to N in any order and no value is repeated.
Examples:
Input: K = 7, a[] = {1, 1, 3, 4, 5, 3, 7, 1}
b[] = {7, 5, 4, 8, 1, 3, 5, 2}
Output: 10
Explanation: In a[] some numbers are repeating which are 1, 1, 3, 3, 1.
Now, make two 1’s and one 3 unique.
Select a[1], a[5] and a[7] and replace them with 2, 6, and 8 to make array a permutation of 1 to 8.
The total cost is b[1] + b[5] + b[7] = 5 + 3 + 2 = 10.
This is the minimum cost to make a[] a permutation of 1 to 8.
Now, a[] becomes {1, 2, 3, 4, 5, 6, 7, 8}Input: K = 3, a[] = {3, 1, 2}
b[] = {5, 3, 4}
Output: 0
Explanation: a[] is already a permutation of 1 to 3. So no need to replace any value.
Approach: The solution of the problem is based on the concept of hashing. Store the elements which are repeating and replace all but the one having the maximum cost for replacement. Follow the steps mentioned below to solve the problem:
- Initialize the map to store a[i] and b[i].
- Initialize vector to store the minimum answer.
- Now traverse both the arrays.
- If a[i] is not present in the map, store a[i] as key and b[i] as a value in the map.
- Else if a[i] is present and the value of a[i] stored in the map is less than b[i], store the existing value of a[i] in a vector v and change the value in map to b[i].
- Else store b[i] in the vector v.
- Sort the vector v.
- Initialize the variable ans = 0.
- Now traverse vector (K – size of map) times and sum all the values of vector in ans.
Below is the implementation of the above approach.
// C++ code to implement the approach #include <bits/stdc++.h> using namespace std;
// Function to calculate the minimum cost int minCost( int a[], int b[], int N, int K)
{ // Initialize map and vector
map< int , int > m;
vector< int > v;
for ( int i = 0; i < N; i++) {
if (m[a[i]] == 0) {
m[a[i]] = b[i];
}
else {
if (m[a[i]] < b[i]) {
v.push_back(m[a[i]]);
m[a[i]] = b[i];
}
else {
v.push_back(b[i]);
}
}
}
sort(v.begin(), v.end());
int size = K - m.size();
int ans = 0;
for ( int i = 0; i < size; i++) {
ans += v[i];
}
return ans;
} // Driver code int main()
{ int a[] = { 1, 1, 3, 1, 5, 3, 7, 1 };
int b[] = { 5, 7, 4, 8, 1, 3, 5, 2 };
int K = 7;
int N = sizeof (a) / sizeof (a[0]);
cout << minCost(a, b, N, K);
return 0;
} |
// JAVA code to implement the approach import java.util.*;
class GFG
{ // Function to calculate the minimum cost
public static int minCost( int [] a, int [] b, int N,
int K)
{
// Initialize map and ArrayList
HashMap<Integer, Integer> m
= new HashMap<Integer, Integer>();
ArrayList<Integer> v = new ArrayList<Integer>();
for ( int i = 0 ; i < N; i++) {
if (m.containsKey(a[i])) {
m.put(a[i], 0 );
}
}
for ( int i = 0 ; i < N; i++) {
if (m.get(a[i]) == null ) {
m.put(a[i], b[i]);
}
else {
if (m.get(a[i]) < b[i]) {
v.add(m.get(a[i]));
m.put(a[i], b[i]);
}
else {
v.add(b[i]);
}
}
}
Collections.sort(v);
int size = K - m.size();
int ans = 0 ;
for ( int i = 0 ; i < size; i++) {
ans += v.get(i);
}
return ans;
}
// Driver code
public static void main(String[] args)
{
int [] a = new int [] { 1 , 1 , 3 , 1 , 5 , 3 , 7 , 1 };
int [] b = new int [] { 5 , 7 , 4 , 8 , 1 , 3 , 5 , 2 };
int K = 7 ;
int N = a.length;
System.out.print(minCost(a, b, N, K));
}
} // This code is contributed by Taranpreet |
// C# code to implement the approach using System;
using System.Collections;
using System.Collections.Generic;
class GFG
{ // Function to calculate the minimum cost
static int minCost( int []a, int []b, int N, int K)
{
// Initialize map and vector
Dictionary< int , int > m =
new Dictionary< int , int >();
ArrayList v = new ArrayList();
for ( int i = 0; i < N; i++) {
if (!m.ContainsKey(a[i])) {
m.Add(a[i], 0);
}
}
for ( int i = 0; i < N; i++) {
if (m[a[i]] == 0) {
m[a[i]] = b[i];
}
else {
if (m[a[i]] < b[i]) {
v.Add(m[a[i]]);
m[a[i]] = b[i];
}
else {
v.Add(b[i]);
}
}
}
v.Sort();
int size = K - m.Count;
int ans = 0;
for ( int i = 0; i < size; i++) {
ans += ( int )v[i];
}
return ans;
}
// Driver code
public static void Main()
{
int []a = { 1, 1, 3, 1, 5, 3, 7, 1 };
int []b = { 5, 7, 4, 8, 1, 3, 5, 2 };
int K = 7;
int N = a.Length;
Console.Write(minCost(a, b, N, K));
}
} // This code is contributed by Samim Hossain Mondal. |
<script> // JavaScript code for the above approach
// Function to calculate the minimum cost
function minCost(a, b, N, K) {
// Initialize map and vector
let m = new Map();
let v = [];
for (let i = 0; i < N; i++) {
if (m.has(a[i]) == false ) {
m.set(a[i], b[i]);
}
else {
if (m.get(a[i]) < b[i]) {
v.push(m.get(a[i]));
m.set(a[i], b[i]);
}
else {
v.push(b[i]);
}
}
}
v.sort( function (a, b) { return a - b })
let size = K - m.size;
let ans = 0;
for (let i = 0; i < size; i++) {
ans += v[i];
}
return ans;
}
// Driver code
let a = [1, 1, 3, 1, 5, 3, 7, 1];
let b = [5, 7, 4, 8, 1, 3, 5, 2];
let K = 7;
let N = a.length;
document.write(minCost(a, b, N, K));
// This code is contributed by Potta Lokesh
</script>
|
# Python code for the above approach # Function to calculate the minimum cost def minCost(a, b, N, K):
# Initialize map and vector
m = {}
v = [];
for i in range (N):
if (a[i] not in m):
m[a[i]] = b[i]
else :
if (m[a[i]] < b[i]):
v.append(m[a[i]]);
m[a[i]] = b[i]
else :
v.append(b[i]);
v.sort()
size = K - len (m);
ans = 0 ;
for i in range (size):
ans + = v[i];
return ans;
# Driver code a = [ 1 , 1 , 3 , 1 , 5 , 3 , 7 , 1 ];
b = [ 5 , 7 , 4 , 8 , 1 , 3 , 5 , 2 ];
K = 7 ;
N = len (a)
print (minCost(a, b, N, K));
# This code is contributed by Saurabh Jaiswal |
10
Time Complexity: O(N * log N)
Auxiliary Space: O(N)