Given an array arr[] of N integers and an integer K. Also given are Q queries which have two numbers L and R. For every query, you can increase all the elements of the array in the index range [L, R] by 1. The task is to choose exactly K queries out of Q queries such that the sum of the array at the end is maximized. Print the sum after performing K such queries.
Examples:
Input: arr[] = {1, 1, 2, 2, 2, 3},
que[] = {{0, 4}, {1, 2}, {2, 5}, {2, 3}, {2, 4}},
K = 3
Output: 23
We choose the first, third and the fifth query.
After performing first query -> arr[] = {2, 2, 3, 3, 3, 3}
After performing third query -> arr[] = {2, 2, 4, 4, 4, 4}
After performing fifth query -> arr[] = {2, 2, 5, 5, 5, 4}
And the array sum is 2 + 2 + 5 + 5 + 5 + 4 = 23.Input: arr[] = {4, 5, 4, 21, 22},
que[] = {{1, 2}, {2, 2}, {2, 4}, {2, 2}},
K = 2
Output: 61
Naive approach: A naive approach is to use Dynamic Programming and Combinatorics, in which we choose any K queries out of Q. The combination which gives the maximum sum of the array will be the answer.
Time Complexity: O(N*N*K)
Efficient Approach: Since we need to maximize the sum of the array at the end. We just need to choose those queries that affect the maximum number of elements from the array i.e. with bigger ranges. Every query contributes (R – L + 1) to the increase in the sum if it is chosen. The sum of the array elements after performing such queries will be (initial sum of the array + (Contribution of K queries)).
Below is the implementation of the above approach:
C++
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std; // Function to perform K queries out // of Q to maximize the final sum int getFinalSum(int a[], int n, pair<int, int> queries[], int q, int k) { int answer = 0; // Get the initial sum // of the array for (int i = 0; i < n; i++) answer += a[i]; vector<int> contribution; // Stores the contriution of every query for (int i = 0; i < q; i++) { contribution.push_back(queries[i].second - queries[i].first + 1); } // Sort the contribution of queries // in descending order sort(contribution.begin(), contribution.end(), greater<int>()); int i = 0; // Get the K most contributions while (i < k) { answer += contribution[i]; i++; } return answer; } // Driver code int main() { int a[] = { 1, 1, 2, 2, 2, 3 }; int n = sizeof(a) / sizeof(a[0]); pair<int, int> queries[] = { { 0, 4 }, { 1, 2 }, { 2, 5 }, { 2, 3 }, { 2, 4 } }; int q = sizeof(queries) / sizeof(queries[0]); int k = 3; cout << getFinalSum(a, n, queries, q, k); return 0; } |
Java
// Java implementation of the approach import java.util.*; class GFG { //pair class static class pair { int first,second; pair(int f,int s) { first = f; second = s; } } // Function to perform K queries out // of Q to maximize the final sum static int getFinalSum(int a[], int n, pair queries[], int q, int k) { int answer = 0; // Get the initial sum // of the array for (int i = 0; i < n; i++) answer += a[i]; Vector<Integer> contribution = new Vector<Integer>(); // Stores the contriution of every query for (int i = 0; i < q; i++) { contribution.add(queries[i].second - queries[i].first + 1); } //compartor Comparator<Integer> Comp = new Comparator<Integer>() { public int compare(Integer e1,Integer e2) { if(e1 > e2) return -1; else return 1; } }; // Sort the contribution of queries // in descending order Collections.sort(contribution,Comp); int i = 0; // Get the K most contributions while (i < k) { answer += (int) contribution.get(i); i++; } return answer; } // Driver code public static void main(String args[]) { int a[] = { 1, 1, 2, 2, 2, 3 }; int n = a.length; pair queries[] = new pair[5]; queries[0] = new pair( 0, 4 ); queries[1] = new pair( 1, 2 ); queries[2] = new pair( 2, 5 ); queries[3] = new pair( 2, 3 ); queries[4] = new pair( 2, 4 ); int q = queries.length; int k = 3; System.out.println( getFinalSum(a, n, queries, q, k)); } } // This code is contributed by Arnab Kundu |
Python3
# Python 3 implementation of the approach # Function to perform K queries out # of Q to maximize the final sum def getFinalSum(a, n, queries, q, k): answer = 0 # Get the initial sum # of the array for i in range(n): answer += a[i] contribution = [] # Stores the contriution of every query for i in range(q): contribution.append(queries[i][1]- queries[i][0] + 1) # Sort the contribution of queries # in descending order contribution.sort(reverse = True) i = 0 # Get the K most contributions while (i < k): answer += contribution[i] i += 1 return answer # Driver code if __name__ == '__main__': a = [1, 1, 2, 2, 2, 3] n = len(a) queries = [[0, 4], [1, 2], [2, 5], [2, 3], [2, 4]] q = len(queries); k = 3 print(getFinalSum(a, n, queries, q, k)) # This code is contributed by # Surendra_Gangwar |
23
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.
Recommended Posts:
- Maximize elements using another array
- Maximize the median of the given array after adding K elements to the same array
- Maximize Array sum by swapping at most K elements with another array
- Maximize difference between the Sum of the two halves of the Array after removal of N elements
- Find sum of all unique elements in the array for K queries
- Minimize count of array elements to be removed to maximize difference between any pair up to K
- Maximize the size of array by deleting exactly k sub-arrays to make array prime
- Maximize distinct elements by incrementing/decrementing an element or keeping it same
- Rearrange an array to maximize i*arr[i]
- Maximize the Sum of the given array using given operations
- Number of elements greater than K in the range L to R using Fenwick Tree (Offline queries)
- Maximize the last Array element as per the given conditions
- Maximize median after doing K addition operation on the Array
- Maximize sum of consecutive differences in a circular array
- Maximize array sum by X increments when each element is divided by 10
- Split array into K subsets to maximize their sum of maximums and minimums
- Maximize 3rd element sum in quadruplet sets formed from given Array
- Sum of elements in 1st array such that number of elements less than or equal to them in 2nd array is maximum
- Maximum sum after rearranging the array for K queries
- Sort elements of an array in increasing order of absolute difference of adjacent elements
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.
