Given an integer N, representing the number of workers, an array speed[ ], where speed[i] represents the speed of the ith worker, and an array efficiency[ ], where efficiency[i] represents the efficiency of the ith worker, and an integer K, the task is to select K workers such that the ( Sum of speeds of all the workers ) * ( Minimum efficiency of among K workers ) is maximum possible.
Examples:
Input: N = 6, speed[] = {2, 10, 3, 1, 5, 8}, efficiency[] = {5, 4, 3, 9, 7, 2}, K = 2
Output: 60
Explanation:
Selecting 2nd worker (Speed = 10 and Efficiency = 4) and 5th worker ( Speed = 5 and Efficiency = 7).
Therefore, the maximum sum possible = (10 + 5) * min(4, 7) = 60Input: N = 6, speed[] = {2, 10, 3, 1, 5, 8}, efficiency[] = {5, 4, 3, 9, 7, 2}, K = 3
Output: 68
Approach: Follow the steps below to solve the problem:
- Initialize a vector of pairs arr[ ] where arr[i] equals {efficiency[i], speed[i]} of size N.
- Sort the arr[ ] in decreasing order of efficiency.
- Initialize a min priority_queue that stores the speed of workers.
- Initialize variables say, SumOfSpeed = 0 and Ans = 0.
- Iterate over arr[ ] and do the following:
- Add arr[i].first to the SumOfSpeed
- Push speed[i] in priority_queue.
- If size of the priority_queue exceeds K, the pop the front of the priority_queue and subtract from SumOfSpeed.
- Update Ans as max of Ans and SumOfSpeed * efficiency[i].
- Finally, return the Ans.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to generate array of pairs void generateArrayofPairs( int n, vector< int >& speed,
vector< int >& efficiency,
vector<pair< int , int > >& arr)
{ for ( int i = 0; i < n; i++) {
arr[i] = { efficiency[i], speed[i] };
}
sort(arr.rbegin(), arr.rend());
} // Function to find the maximum // product of worker speeds and // their minimum efficiency int maximizePerformance(vector< int >& speed, int K,
vector< int >& efficiency)
{ int n = speed.size();
vector<pair< int , int > > arr(n);
// Function to generate
// sorted array of pairs
generateArrayofPairs(n, speed,
efficiency, arr);
// Initialize priority queue
priority_queue< int , vector< int >,
greater< int > >
pq;
// Initialize ans and sumofspeed
int ans = 0;
int SumOfSpeed = 0;
// Traversing the arr of pairs
for ( auto & it : arr) {
int e = it.first;
int s = it.second;
// Updating sum of speed
SumOfSpeed += s;
// Pushing in priority queue
pq.push(s);
// If team consists of more than
// K workers
if (pq.size() > K) {
int temp = pq.top();
SumOfSpeed -= temp;
pq.pop();
}
// Taking the maximum performance
// that can be formed
ans = max(ans, SumOfSpeed * e);
}
// Finally return the ans
return ans;
} // Driver Code int main()
{ // Given Input
vector< int > speed = { 2, 10, 3, 1, 5, 8 };
vector< int > efficiency = { 5, 4, 3, 9, 7, 2 };
int K = 2;
// Function Call
cout << maximizePerformance(
speed, K, efficiency);
} |
// Java program for the above approach import java.io.*;
import java.util.*;
class GFG {
static class pair
{ int first, second;
public pair( int first, int second)
{
this .first = first;
this .second = second;
}
} // Function to generate array of pairs static void generateArrayofPairs( int n, Vector<Integer> speed,
Vector<Integer> efficiency,
Vector<pair > arr)
{ for ( int i = 0 ; i < n; i++) {
arr.insertElementAt( new pair(efficiency.elementAt(i), speed.elementAt(i)), i);
}
Collections.sort(arr, new Comparator<pair>() {
@Override public int compare(pair p1, pair p2)
{
if (p1.first != p2.first)
return (p2.first - p1.first);
return p2.second - p1.second;
}
});
} // Function to find the maximum // product of worker speeds and // their minimum efficiency static int maximizePerformance(Vector<Integer> speed, int K,
Vector<Integer> efficiency)
{ int n = speed.size();
Vector<pair > arr = new Vector<>();
// Function to generate
// sorted array of pairs
generateArrayofPairs(n, speed,
efficiency, arr);
// Initialize priority queue
PriorityQueue<Integer> pq = new PriorityQueue<Integer>();
// Initialize ans and sumofspeed
int ans = 0 ;
int SumOfSpeed = 0 ;
// Traversing the arr of pairs
for ( int i = 0 ; i < arr.size(); i++) {
int e = arr.elementAt(i).first;
int s = arr.elementAt(i).second;
// Updating sum of speed
SumOfSpeed += s;
// Pushing in priority queue
pq.add(s);
// If team consists of more than
// K workers
if (pq.size() > K) {
int temp = pq.peek();
SumOfSpeed -= temp;
pq.poll();
}
// Taking the maximum performance
// that can be formed
ans = Math.max(ans, SumOfSpeed * e);
}
// Finally return the ans
return ans;
} // Driver Code public static void main (String[] args) {
// Given Input
Vector<Integer> speed = new Vector<Integer>();
speed.add( 2 );
speed.add( 10 );
speed.add( 3 );
speed.add( 1 );
speed.add( 5 );
speed.add( 8 );
Vector<Integer> efficiency = new Vector<Integer>();
efficiency.add( 5 );
efficiency.add( 4 );
efficiency.add( 3 );
efficiency.add( 9 );
efficiency.add( 7 );
efficiency.add( 2 );
int K = 2 ;
// Function Call
System.out.println(maximizePerformance(
speed, K, efficiency));
} } // This code is contributed by Dharanendra L V. |
# Python program for the above approach # Function to generate array of pairs from functools import cmp_to_key
def mycmp1(a, b):
if (b[ 0 ] = = a[ 0 ]):
return b[ 1 ] - a[ 1 ]
return b[ 0 ] - a[ 0 ]
def mycmp2(a,b):
return b - a
def generateArrayofPairs(n, speed, efficiency, arr):
for i in range (n):
arr[i] = [ efficiency[i], speed[i] ]
arr.sort(key = cmp_to_key(mycmp1))
return arr
# Function to find the maximum # product of worker speeds and # their minimum efficiency def maximizePerformance(speed, K, efficiency):
n = len (speed)
arr = [[ 0 for j in range ( 2 )] for i in range (n)]
# Function to generate
# sorted array of pairs
arr = generateArrayofPairs(n, speed,efficiency, arr)
# Initialize priority queue
pq = []
# Initialize ans and sumofspeed
ans = 0
SumOfSpeed = 0
# Traversing the arr of pairs
for it in arr:
e = it[ 0 ]
s = it[ 1 ]
# Updating sum of speed
SumOfSpeed + = s
# Pushing in priority queue
pq.append(s)
pq.sort(key = cmp_to_key(mycmp2))
# If team consists of more than
# K workers
if ( len (pq) > K):
temp = pq[ len (pq) - 1 ]
SumOfSpeed - = temp
pq.pop()
# Taking the maximum performance
# that can be formed
ans = max (ans, SumOfSpeed * e)
# Finally return the ans
return ans
# Driver Code # Given Input speed = [ 2 , 10 , 3 , 1 , 5 , 8 ]
efficiency = [ 5 , 4 , 3 , 9 , 7 , 2 ]
K = 2
# Function Call print (maximizePerformance(speed, K, efficiency))
# This code is contributed by shinjanpatra |
// C# program for the above approach using System;
using System.Collections.Generic;
class GFG
{ public class Pair
{
public int first, second;
public Pair( int first, int second)
{
this .first = first;
this .second = second;
}
}
// Function to generate array of pairs
static void generateArrayofPairs( int n, List< int > speed,
List< int > efficiency,
List<Pair> arr)
{
for ( int i = 0; i < n; i++)
{
arr.Insert(i, new Pair(efficiency[i], speed[i]));
}
arr.Sort((pair1, pair2) =>
{
if (pair1.first != pair2.first)
return pair2.first - pair1.first;
return pair2.second - pair1.second;
});
}
// Function to find the maximum
// product of worker speeds and
// their minimum efficiency
static int maximizePerformance(List< int > speed, int K,
List< int > efficiency)
{
int n = speed.Count;
List<Pair> arr = new List<Pair>();
// Function to generate
// sorted array of pairs
generateArrayofPairs(n, speed,
efficiency, arr);
// Initialize priority queue
SortedSet< int > pq = new SortedSet< int >();
// Initialize ans and sumofspeed
int ans = 0;
int SumOfSpeed = 0;
// Traversing the arr of pairs
for ( int i = 0; i < arr.Count; i++)
{
int e = arr[i].first;
int s = arr[i].second;
// Updating sum of speed
SumOfSpeed += s;
// Pushing in priority queue
pq.Add(s);
// If team consists of more than
// K workers
if (pq.Count > K)
{
int temp = pq.Min;
SumOfSpeed -= temp;
pq.Remove(temp);
}
// Taking the maximum performance
// that can be formed
ans = Math.Max(ans, SumOfSpeed * e);
}
// Finally return the ans
return ans;
}
// Driver Code
public static void Main( string [] args)
{
// Given Input
List< int > speed = new List< int >() { 2, 10, 3, 1, 5, 8 };
List< int > efficiency = new List< int >() { 5, 4, 3, 9, 7, 2 };
int K = 2;
// Function Call
Console.WriteLine(maximizePerformance(speed, K, efficiency));
}
} |
<script> // Javascript program for the above approach // Function to generate array of pairs function generateArrayofPairs(n, speed, efficiency, arr)
{ for ( var i = 0; i < n; i++) {
arr[i] = [ efficiency[i], speed[i] ];
}
arr.sort((a,b)=>{
if (b[0] == a[0])
return b[1] - a[1]
return b[0] - a[0];
});
return arr;
} // Function to find the maximum // product of worker speeds and // their minimum efficiency function maximizePerformance(speed, K, efficiency)
{ var n = speed.length;
var arr = Array.from(Array(n),()=> new Array(2).fill(0));
// Function to generate
// sorted array of pairs
arr = generateArrayofPairs(n, speed,
efficiency, arr);
// Initialize priority queue
var pq = [];
// Initialize ans and sumofspeed
var ans = 0;
var SumOfSpeed = 0;
// Traversing the arr of pairs
for ( var it of arr) {
var e = it[0];
var s = it[1];
// Updating sum of speed
SumOfSpeed += s;
// Pushing in priority queue
pq.push(s);
pq.sort((a,b)=>b-a);
// If team consists of more than
// K workers
if (pq.length > K) {
var temp = pq[pq.length-1];
SumOfSpeed -= temp;
pq.pop();
}
// Taking the maximum performance
// that can be formed
ans = Math.max(ans, SumOfSpeed * e);
}
// Finally return the ans
return ans;
} // Driver Code // Given Input var speed = [2, 10, 3, 1, 5, 8 ];
var efficiency = [5, 4, 3, 9, 7, 2 ];
var K = 2;
// Function Call document.write(maximizePerformance(speed, K, efficiency)); // This code is contributed by rrrtnx. </script> |
60
Time Complexity: O(NLogN)
Auxiliary Space: O(N)