Maximum sum after rearranging the array for K queries
Last Updated :
04 Jan, 2023
Given two arrays arr[] containing N integers and Q[][] containing K queries where every query represents a range [L, R]. The task is to rearrange the array and find the maximum possible sum of all the subarrays where each subarray is defined by the elements of the array in the range [L, R] given by each query.
Note: 1-based indexing is used in the Q[][] array to signify the ranges.
Examples:
Input: arr[] = { 2, 6, 10, 1, 5, 6 }, Q[][2] = {{1, 3}, {4, 6}, {3, 4}}
Output: 46
Explanation:
One possible way is to rearrange the array to arr[] = {2, 6, 10, 6, 5, 1}.
In this arrangement:
The sum of the subarray in the range [1, 3] = 2 + 6 + 10 = 18.
The sum of the subarray in the range [4, 6] = 6 + 5 + 1 = 12.
The sum of the subarray in the range [3, 4] = 10 + 6 = 16.
The total sum of all the subarrays = 46 which is the maximum possible.
Input: arr[] = { 1, 2, 3, 4, 5, 6, 7, 8 }, Q[][2] = {{1, 4}, {5, 5}, {7, 8}, {8, 8}}
Output: 43
Explanation:
One possible way is to rearrange the array to arr[] = {2, 3, 4, 5, 6, 1, 7, 8}.
In this arrangement:
The sum of the subarray in the range [1, 4] = 2 + 3 + 4 + 5 = 14.
The sum of the subarray in the range [5, 5] = 6 = 6.
The sum of the subarray in the range [7, 8] = 7 + 8 = 15.
The sum of the subarray in the range [8, 8] = 8 = 8.
The total sum of all the subarrays = 43 which is the maximum possible.
Approach: On observing clearly, one conclusion which can be made is that we get the maximum sum when the maximum elements are included in as many subarrays as possible. For this, we need to find the number of times every index is included by iterating all the queries.
For example: Let the array be arr[] = {2, 6, 10, 6, 5, 1} and the queries be Q[][] = {{1, 3}, {4, 6}, {3, 4}}.
- Step 1: Create a count array C[] of size N. So, initially, the count array C[] = {0, 0, 0, 0, 0, 0}.
- Step 2: For the query [1, 3], the elements at the index [1, 3] are incremented by 1. The count array after this query becomes {1, 1, 1, 0, 0, 0}.
- Step 3: Similarly, for the next query, the count array becomes {1, 1, 1, 1, 1, 1} and finally, after the third query, the count array becomes {1, 1, 2, 2, 1, 1}.
- Step 4: After obtaining the count array, the idea is to use sorting to get the maximum sum.
- Step 5: After sorting, the array C[] = {1, 1, 1, 1, 2, 2} and arr[] = {1, 2, 5, 6, 6, 10}. The maximum possible sum is the weighted sum of both the arrays, i.e.:
sum = ((1 * 1) + (1 * 2) + (1 * 5) + (1 * 6) + (2 * 6) + (2 * 10)) = 46
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int maxSumArrangement( int A[], int R[][2],
int N, int M)
{
int count[N];
memset (count, 0, sizeof count);
for ( int i = 0; i < M; ++i) {
int l = R[i][0], r = R[i][1] + 1;
l--;
r--;
count[l]++;
if (r < N)
count[r]--;
}
for ( int i = 1; i < N; ++i) {
count[i] += count[i - 1];
}
int ans = 0;
sort(count, count + N);
sort(A, A + N);
for ( int i = N - 1; i >= 0; --i) {
ans += A[i] * count[i];
}
return ans;
}
int main()
{
int A[] = { 2, 6, 10, 1, 5, 6 };
int R[][2]
= { { 1, 3 }, { 4, 6 }, { 3, 4 } };
int N = sizeof (A) / sizeof (A[0]);
int M = sizeof (R) / sizeof (R[0]);
cout << maxSumArrangement(A, R, N, M);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int maxSumArrangement( int A[], int R[][],
int N, int M)
{
int count[] = new int [N];
int i;
for ( i = 0 ; i < M; ++i) {
int l = R[i][ 0 ], r = R[i][ 1 ] + 1 ;
l--;
r--;
count[l]++;
if (r < N)
count[r]--;
}
for (i = 1 ; i < N; ++i) {
count[i] += count[i - 1 ];
}
int ans = 0 ;
Arrays.sort( count);
Arrays.sort(A);
for (i = N - 1 ; i >= 0 ; --i) {
ans += A[i] * count[i];
}
return ans;
}
public static void main(String []args)
{
int A[] = { 2 , 6 , 10 , 1 , 5 , 6 };
int R[][]
= { { 1 , 3 }, { 4 , 6 }, { 3 , 4 } };
int N = A.length;
int M = R.length;
System.out.print(maxSumArrangement(A, R, N, M));
}
}
|
Python3
def maxSumArrangement( A, R, N, M):
count = [ 0 for i in range (N)]
for i in range (M):
l = R[i][ 0 ]
r = R[i][ 1 ] + 1
l = l - 1
r = r - 1
count[l] = count[l] + 1
if (r < N):
count[r] = count[r] - 1
for i in range ( 1 , N):
count[i] = count[i] + count[i - 1 ]
ans = 0
count.sort()
A.sort()
for i in range (N - 1 , - 1 , - 1 ):
ans = ans + A[i] * count[i]
return ans
A = [ 2 , 6 , 10 , 1 , 5 , 6 ]
R = [ [ 1 , 3 ], [ 4 , 6 ], [ 3 , 4 ] ]
N = len (A)
M = len (R)
print (maxSumArrangement(A, R, N, M))
|
C#
using System;
class GFG
{
static int maxSumArrangement( int []A, int [,]R,
int N, int M)
{
int []count = new int [N];
int i;
for ( i = 0; i < M; ++i) {
int l = R[i, 0], r = R[i, 1] + 1;
l--;
r--;
count[l]++;
if (r < N)
count[r]--;
}
for (i = 1; i < N; ++i) {
count[i] += count[i - 1];
}
int ans = 0;
Array.Sort( count);
Array.Sort(A);
for (i = N - 1; i >= 0; --i) {
ans += A[i] * count[i];
}
return ans;
}
public static void Main(String []args)
{
int []A = { 2, 6, 10, 1, 5, 6 };
int [,]R
= { { 1, 3 }, { 4, 6 }, { 3, 4 } };
int N = A.Length;
int M = R.GetLength(0);
Console.Write(maxSumArrangement(A, R, N, M));
}
}
|
Javascript
<script>
function arrSort(a, n) {
var i, j, min, temp;
for (i = 0; i < n - 1; i++) {
min = i;
for (j = i + 1; j < n; j++)
if (a[j] < a[min])
min = j;
temp = a[i];
a[i] = a[min];
a[min] = temp;
}
}
function maxSumArrangement(A, R, N, M)
{
var count = new Array(N);
count.fill(0);
for ( var i = 0; i < M; i++) {
var l = R[i][0], r = R[i][1] + 1;
l--;
r--;
count[l]++;
if (r < N)
count[r]--;
}
for ( var i = 1; i < N; ++i) {
count[i] += count[i - 1];
}
var ans = 0;
count.sort();
arrSort(A,N);
for ( var i = N - 1; i >= 0; --i) {
ans += A[i] * count[i];
}
return ans;
}
var A = [ 2, 6, 10, 1, 5, 6 ];
var R = [ [ 1, 3 ], [ 4, 6 ], [ 3, 4 ] ];
var N = A.length;
var M = R.length;
document.write( maxSumArrangement(A, R, N, M));
</script>
|
Time Complexity: O(N* log(N))
Auxiliary Space: O(N), where N is the size of the given array.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...