Minimize Cost by selecting Distinct values from Array A
Last Updated :
04 Dec, 2023
Improve
Given an array A and cost array B of size N. The task is to determine the minimum cost(given in array B) by choosing all distinct values from array A.
Note: A[i] will cost us B[i]
Examples:
Input: N = 2, A[] = {16, 16}, B[] = {1, 2}
Output: 1
Explanation: Choosing 16 at the first index will be optimal.Input: N = 3, A[] = {3, 4, 3}, B[] = {3, 2, 1}
Output: 3
Approach: To solve the problem follow the below idea:
Using map data structure, store the elements in A as key, and if we encounter less value in B for the same element, Update it.
Below are the steps involved:
- Declare a map data structure m.
- The key for the map will be valued in A and the value for the map will be cost in B.
- If we encounter the same key in array A:
- Update the corresponding value to minimum of value already existing or current cost.
- Initialize a sum variable.
- Iterate in map:
- Sum will be incremented by values of map
- Return sum.
Below is the implementation of the code:
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
// Function to find minimum sum
int solve(int A[], int B[], int N)
{
// Map declaration
unordered_map<int, int> m;
int i = 0;
while (i < N) {
if (m.find(A[i]) != m.end()) {
// Update if value is present
if (m[A[i]] > B[i]) {
m[A[i]] = B[i];
}
}
else {
m[A[i]] = B[i];
}
i++;
}
int sum = 0;
for (auto a : m) {
sum += a.second;
}
return sum;
}
// Driver code
int main()
{
int N = 4;
int A[] = { 3, 16, 3, 4 };
int B[] = { 3, 9, 1, 1 };
// Function call
cout << solve(A, B, N);
return 0;
}
import java.util.HashMap;
public class MinimumSum {
// Function to find minimum sum
static int solve(int[] A, int[] B, int N) {
// Map declaration
HashMap<Integer, Integer> map = new HashMap<>();
int i = 0;
while (i < N) {
if (map.containsKey(A[i])) {
// Update if value is present
if (map.get(A[i]) > B[i]) {
map.put(A[i], B[i]);
}
} else {
map.put(A[i], B[i]);
}
i++;
}
int sum = 0;
// Calculating the sum of minimum values
for (int value : map.values()) {
sum += value;
}
return sum;
}
// Driver code
public static void main(String[] args) {
int N = 4;
int[] A = { 3, 16, 3, 4 };
int[] B = { 3, 9, 1, 1 };
// Function call
System.out.println(solve(A, B, N));
}
}
# Function to find minimum sum
def solve(A, B, N):
# Dictionary declaration
m = {}
i = 0
while i < N:
if A[i] in m:
# Update if value is present
if m[A[i]] > B[i]:
m[A[i]] = B[i]
else:
m[A[i]] = B[i]
i += 1
sum_value = 0
for key, value in m.items():
sum_value += value
return sum_value
# Driver code
if __name__ == "__main__":
N = 4
A = [3, 16, 3, 4]
B = [3, 9, 1, 1]
# Function call
print(solve(A, B, N))
using System;
using System.Collections.Generic;
public class Program
{
// Function to find minimum sum
public static int Solve(int[] A, int[] B, int N)
{
// Dictionary declaration
Dictionary<int, int> m = new Dictionary<int, int>();
int i = 0;
while (i < N)
{
if (m.ContainsKey(A[i]))
{
// Update if value is present
if (m[A[i]] > B[i])
{
m[A[i]] = B[i];
}
}
else
{
m[A[i]] = B[i];
}
i++;
}
int sum = 0;
foreach (var a in m)
{
sum += a.Value;
}
return sum;
}
// Driver code
public static void Main(string[] args)
{
int N = 4;
int[] A = { 3, 16, 3, 4 };
int[] B = { 3, 9, 1, 1 };
// Function call
Console.WriteLine(Solve(A, B, N));
}
}
function GFG(A, B, N) {
// Create an object (dictionary) to store the minimum values for
// each unique element in A
const m = {};
for (let i = 0; i < N; i++) {
if (m[A[i]] !== undefined) {
// Update if the value is present and is greater than
// the current B value
if (m[A[i]] > B[i]) {
m[A[i]] = B[i];
}
} else {
// Set the value if not present
m[A[i]] = B[i];
}
}
// Calculate the sum of minimum values
let sumValue = 0;
for (const key in m) {
if (m.hasOwnProperty(key)) {
sumValue += m[key];
}
}
return sumValue;
}
// Driver Code
const N = 4;
const A = [3, 16, 3, 4];
const B = [3, 9, 1, 1];
// Function call
console.log(GFG(A, B, N));
Output
11
Time Complexity: O(N)
Auxiliary space: O(N)
