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++
// C++ program to find the maximum sum// after rearranging the array for K queriesÂ
#include <bits/stdc++.h>using namespace std;Â
// Function to find maximum sum after// rearranging array elementsint maxSumArrangement(int A[], int R[][2],                      int N, int M){Â
    // Auxiliary array to find the    // count of each selected elements    int count[N];Â
    // Initialize with 0    memset(count, 0, sizeof count);Â
    // Finding count of every element    // to be selected    for (int i = 0; i < M; ++i) {Â
        int l = R[i][0], r = R[i][1] + 1;Â
        // Making it to 0-indexing        l--;        r--;Â
        // Prefix sum array concept is used        // to obtain the count array        count[l]++;Â
        if (r < N)            count[r]--;    }Â
    // Iterating over the count array    // to get the final array    for (int i = 1; i < N; ++i) {        count[i] += count[i - 1];    }Â
    // Variable to store the maximum sum    int ans = 0;Â
    // Sorting both the arrays    sort(count, count + N);    sort(A, A + N);Â
       // Loop to find the maximum sum    for (int i = N - 1; i >= 0; --i) {        ans += A[i] * count[i];    }Â
    return ans;}Â
// Driver codeint 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
// Java program to find the maximum sum// after rearranging the array for K queriesimport java.util.*;Â
class GFG{          // Function to find maximum sum after    // rearranging array elements    static int maxSumArrangement(int A[], int R[][],                          int N, int M)    {              // Auxiliary array to find the        // count of each selected elements        int count[] = new int[N];        int i;              // Finding count of every element        // to be selected        for ( i = 0; i < M; ++i) {                  int l = R[i][0], r = R[i][1] + 1;                  // Making it to 0-indexing            l--;            r--;                  // Prefix sum array concept is used            // to obtain the count array            count[l]++;                  if (r < N)                count[r]--;        }              // Iterating over the count array        // to get the final array        for (i = 1; i < N; ++i) {            count[i] += count[i - 1];        }              // Variable to store the maximum sum        int ans = 0;              // Sorting both the arrays        Arrays.sort( count);        Arrays.sort(A);              // Loop to find the maximum sum        for (i = N - 1; i >= 0; --i) {            ans += A[i] * count[i];        }              return ans;    }          // Driver code    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));          }}Â
// This code is contributed by chitranayal |
Python3
# Python3 program to find the maximum sum # after rearranging the array for K queries Â
# Function to find maximum sum after # rearranging array elements def maxSumArrangement( A, R, N, M):Â
    # Auxiliary array to find the     # count of each selected elements     # Initialize with 0     count = [0 for i in range(N)]Â
    # Finding count of every element     # to be selected     for i in range(M):Â
        l = R[i][0]        r = R[i][1] + 1Â
        # Making it to 0-indexing         l = l - 1        r = r - 1Â
        # Prefix sum array concept is used         # to obtain the count array         count[l] = count[l] + 1Â
        if (r < N):            count[r] = count[r] - 1Â
    # Iterating over the count array     # to get the final array     for i in range(1, N):         count[i] = count[i] + count[i - 1]Â
    # Variable to store the maximum sum     ans = 0Â
    # Sorting both the arrays     count.sort()    A.sort()Â
    # Loop to find the maximum sum     for i in range(N - 1, -1, -1):         ans = ans + A[i] * count[i]Â
    return ansÂ
# Driver code 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))Â
# This code is contributed by Sanjit_Prasad |
C#
// C# program to find the maximum sum// after rearranging the array for K queriesusing System;Â
class GFG{           // Function to find maximum sum after    // rearranging array elements    static int maxSumArrangement(int []A, int [,]R,                          int N, int M)    {               // Auxiliary array to find the        // count of each selected elements        int []count = new int[N];        int i;               // Finding count of every element        // to be selected        for ( i = 0; i < M; ++i) {                   int l = R[i, 0], r = R[i, 1] + 1;                   // Making it to 0-indexing            l--;            r--;                   // Prefix sum array concept is used            // to obtain the count array            count[l]++;                   if (r < N)                count[r]--;        }               // Iterating over the count array        // to get the readonly array        for (i = 1; i < N; ++i) {            count[i] += count[i - 1];        }               // Variable to store the maximum sum        int ans = 0;               // Sorting both the arrays        Array.Sort( count);        Array.Sort(A);               // Loop to find the maximum sum        for (i = N - 1; i >= 0; --i) {            ans += A[i] * count[i];        }               return ans;    }           // Driver code    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));         }}Â
// This code is contributed by Princi Singh |
Javascript
<script>//Javascript program to find the maximum sum// after rearranging the array for K queriesÂ
Â
Â
//function to sort a arrayfunction 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 to find maximum sum after// rearranging array elementsfunction maxSumArrangement(A, R, N, M){Â
    // Auxiliary array to find the    // count of each selected elements    var count = new Array(N);Â
    // Initialize with 0    count.fill(0);Â
    // Finding count of every element    // to be selected    for (var i = 0; i < M; i++) {Â
        var l = R[i][0], r = R[i][1] + 1;Â
        // Making it to 0-indexing        l--;        r--;Â
        // Prefix sum array concept is used        // to obtain the count array        count[l]++;Â
        if (r < N)            count[r]--;    }Â
    // Iterating over the count array    // to get the final array    for (var i = 1; i < N; ++i) {        count[i] += count[i - 1];    }Â
    // Variable to store the maximum sum    var ans = 0;Â
    // Sorting both the arrays    count.sort();    arrSort(A,N);Â
    // Loop to find the maximum sum    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));Â
//This code is contributed by SoumikMondal</script> |
Output:Â
46
Â
Time Complexity: O(N* log(N))
Auxiliary Space: O(N), where N is the size of the given array.
Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
