Maximum Sum Obtained of Any Permutation

Maximum Sum Obtained of Any Permutation - Problem

We have an array of integers, nums, and an array of requests where requests[i] = [start_i, end_i]. The i^th request asks for the sum of nums[start_i] + nums[start_i + 1] + ... + nums[end_i - 1] + nums[end_i]. Both start_i and end_i are 0-indexed.

Return the maximum total sum of all requests among all permutations of nums.

Since the answer may be too large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

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

› Output: 11

💡 Note: Optimal permutation is [3,2,2,1]. Request [0,1] sums to 3+2=5, request [1,3] sums to 2+2+1=5. Total: 5+5=10. Wait, let me recalculate: [2,3,2,1] gives request [0,1]=2+3=5, request [1,3]=3+2+1=6, total=11.

Example 2 — Single Request

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

› Output: 12

💡 Note: Place largest values at positions 1,2,3: optimal arrangement could be [1,5,4,3,2] or [2,5,4,3,1]. Request [1,3] sums to 5+4+3=12.

Example 3 — Overlapping Requests

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

› Output: 5

💡 Note: Optimal permutation [2,1]. Request [0,0] sums to 2, request [0,1] sums to 2+1=3. Total: 2+3=5.

Constraints

n == nums.length
1 ≤ n ≤ 10⁵
0 ≤ nums[i] ≤ 10⁵
1 ≤ requests.length ≤ 10⁵
requests[i].length == 2
0 ≤ start_i ≤ end_i < n

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 f Facebook 15

The key insight is to use frequency counting with prefix sums to determine how often each array position is used in requests, then greedily match the highest values with the most frequently used positions. Best approach uses greedy algorithm with sorting. Time: O(n log n), Space: O(n).

Common Approaches

✓ Brute Force - Try All Permutations

⏱️ Time: O(n! × m × n) Space: O(n)

Generate all possible permutations of the nums array, calculate the total sum of all requests for each permutation, and return the maximum sum found.

Greedy with Frequency Counting

⏱️ Time: O(n log n + m) Space: O(n)

Count how many times each array position appears in requests using prefix sums. Sort numbers in descending order and positions by frequency in descending order. Pair them greedily.

Brute Force - Try All Permutations — Algorithm Steps

Generate all permutations of nums
For each permutation, calculate sum of all requests
Track maximum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible arrangements of [1,2,3,2]

Calculate Each Sum

For each arrangement, sum all request ranges

Find Maximum

Return the highest sum found

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_SIZE 10

int maxSum = 0;
int allPerms[5040][MAX_SIZE];
int permCount = 0;

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

void generatePermutations(int* nums, int numsSize, int start) {
    if (start == numsSize) {
        for (int i = 0; i < numsSize; i++) {
            allPerms[permCount][i] = nums[i];
        }
        permCount++;
        return;
    }
    
    for (int i = start; i < numsSize; i++) {
        swap(&nums[start], &nums[i]);
        generatePermutations(nums, numsSize, start + 1);
        swap(&nums[start], &nums[i]);
    }
}

int solution(int* nums, int numsSize, int** requests, int requestsSize) {
    permCount = 0;
    maxSum = 0;
    
    generatePermutations(nums, numsSize, 0);
    
    for (int p = 0; p < permCount; p++) {
        long long currentSum = 0;
        for (int r = 0; r < requestsSize; r++) {
            int start = requests[r][0];
            int end = requests[r][1];
            for (int i = start; i <= end; i++) {
                currentSum = (currentSum + allPerms[p][i]) % MOD;
            }
        }
        if (currentSum > maxSum) {
            maxSum = currentSum;
        }
    }
    
    return maxSum;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int nums[MAX_SIZE], numsSize;
    parseArray(line1, nums, &numsSize);
    
    int** requests = malloc(MAX_SIZE * sizeof(int*));
    for (int i = 0; i < MAX_SIZE; i++) {
        requests[i] = malloc(2 * sizeof(int));
    }
    
    int requestsSize = 0;
    char* p = line2;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == '[') {
            p++;
            requests[requestsSize][0] = (int)strtol(p, &p, 10);
            while (*p == ' ' || *p == ',') p++;
            requests[requestsSize][1] = (int)strtol(p, &p, 10);
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
            requestsSize++;
        } else if (*p == ']') {
            break;
        } else {
            p++;
        }
    }
    
    printf("%d\n", solution(nums, numsSize, requests, requestsSize));
    
    for (int i = 0; i < MAX_SIZE; i++) {
        free(requests[i]);
    }
    free(requests);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × m × n)

n! permutations, each requiring m requests × average n/2 range size

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current permutation

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

850 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