Maximum Sum Obtained of Any Permutation - Practice Coding Problems

Maximum Sum Obtained of Any Permutation - Problem

You're given an array of integers nums and an array of requests where each request specifies a range [start, end]. Each request asks for the sum of all elements in that range.

Your goal is to rearrange the array to maximize the total sum of all requests combined. Since you can permute the array however you want, you need to strategically place larger numbers where they'll be used most frequently.

For example, if nums = [1, 2, 3, 4, 5] and you have requests for ranges [0, 1] and [1, 3], you'd want to place larger numbers at positions that appear in multiple requests (like position 1).

Return the maximum possible total sum modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,2,3,4,5], requests = [[1,3],[0,1]]

› Output: 19

💡 Note: Position 1 appears in both requests (frequency=2), positions 0,2,3 appear once each (frequency=1). Optimal arrangement: place 5 at position 1, then 4,3,2,1 at remaining positions. Sum = (4+5+3+2) + (1+4) = 14 + 5 = 19

example_2.py — Single Request

$ Input: nums = [1,2,3,4,5], requests = [[0,2]]

› Output: 12

💡 Note: Only one request covers positions 0,1,2. Place largest numbers [5,4,3] at these positions. Sum = 5 + 4 + 3 = 12

example_3.py — Overlapping Ranges

$ Input: nums = [1,2,3], requests = [[0,0],[1,2],[0,2]]

› Output: 10

💡 Note: Frequencies: pos 0→2 times, pos 1→2 times, pos 2→2 times. All positions equally frequent, so any arrangement gives same sum: (3+2+1) * 2 - (3+2+1) = 12 - 6 = 6. Wait, let me recalculate: requests sum positions [0], [1,2], [0,1,2]. Best arrangement [3,2,1]: 3 + (2+1) + (3+2+1) = 3+3+6 = 12. Actually, with arrangement [3,2,1]: request sums are 3, (2+1)=3, (3+2+1)=6, total=12. But better arrangement [2,3,1]: 2 + (3+1)=4 + (2+3+1)=6 = 12. Let me try [1,3,2]: 1 + (3+2)=5 + (1+3+2)=6 = 12. Hmm, let me recalculate systematically...

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁵
1 ≤ requests.length ≤ 10⁵
requests[i].length == 2
0 ≤ starti ≤ endi < nums.length

Visualization

Tap to expand

Understanding the Visualization

Count Tour Visits

Count how many tour groups visit each seat section

Rank Guests & Seats

Sort VIP guests by importance and seats by popularity

Optimal Assignment

Place the most important guests in the most popular seats

Calculate Satisfaction

Sum up the total satisfaction across all tour groups

Key Takeaway

🎯 Key Insight: The greedy approach works because it maximizes the contribution of each number by placing larger values where they'll be counted most often across all requests.

Asked in

G Google 45 a Amazon 38 f Meta 25 ⊞ Microsoft 22

The optimal solution uses a greedy frequency counting approach. First, count how often each position is requested using a difference array technique. Then sort both the frequency counts and the input numbers. Finally, use a greedy pairing strategy: match the largest numbers with the most frequently requested positions. This works because placing larger values in more frequent positions maximally contributes to the total sum.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Permutations)	O(n! × m × k)	O(n)	Generate all possible permutations and calculate the sum for each
Frequency Count + Greedy Assignment (Optimal)	O(n log n + m)	O(n)	Count how often each position is requested, then greedily assign largest numbers to most frequent positions

Brute Force (Try All Permutations) — Algorithm Steps

Generate all possible permutations of the input array
For each permutation, calculate the sum of all requested ranges
Keep track of the maximum sum found
Return the maximum sum modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutation

Create a new arrangement of the array

Calculate Request Sums

Sum all requested ranges for this permutation

Update Maximum

Keep track of the best sum found so far

Repeat

Try the next permutation until all are exhausted

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

const int MOD = 1000000007;
long long maxSum = 0;

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void permute(int* nums, int start, int n, int requests[][2], int reqCount) {
    if (start == n) {
        long long currentSum = 0;
        for (int i = 0; i < reqCount; i++) {
            for (int j = requests[i][0]; j <= requests[i][1]; j++) {
                currentSum += nums[j];
            }
        }
        if (currentSum > maxSum) {
            maxSum = currentSum;
        }
        return;
    }
    
    for (int i = start; i < n; i++) {
        swap(&nums[start], &nums[i]);
        permute(nums, start + 1, n, requests, reqCount);
        swap(&nums[start], &nums[i]);
    }
}

int maxSumRangeQuery(int* nums, int numsSize, int requests[][2], int reqCount) {
    maxSum = 0;
    permute(nums, 0, numsSize, requests, reqCount);
    return maxSum % MOD;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × m × k)

n! permutations, m requests per permutation, average k elements per request

⚠ Quadratic Growth

Space Complexity

O(n)

Space to store current permutation and recursion stack

⚡ Linearithmic Space

23.8K Views

Medium-High Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler