Maximum Elegance of a K-Length Subsequence

Maximum Elegance of a K-Length Subsequence - Problem

Array Hash Table Stack Greedy Sorting Heap (Priority Queue) Hard

You are given a 0-indexed 2D integer array items of length n and an integer k.

items[i] = [profit_i, category_i], where profit_i and category_i denote the profit and category of the i^th item respectively.

Let's define the elegance of a subsequence of items as total_profit + distinct_categories², where total_profit is the sum of all profits in the subsequence, and distinct_categories is the number of distinct categories from all the categories in the selected subsequence.

Your task is to find the maximum elegance from all subsequences of size k in items.

Return an integer denoting the maximum elegance of a subsequence of items with size exactly k.

Input & Output

Example 1 — Basic Case

$ Input: items = [[3,2],[5,1],[10,1]], k = 2

› Output: 17

💡 Note: Select items [5,1] and [10,1]: total_profit = 15, distinct_categories = 1, elegance = 15 + 1² = 16. Alternative: [3,2] and [10,1]: total_profit = 13, distinct_categories = 2, elegance = 13 + 2² = 17 (optimal).

Example 2 — Higher Diversity Bonus

$ Input: items = [[3,1],[3,1],[5,2],[6,3]], k = 3

› Output: 23

💡 Note: Select [6,3], [5,2], [3,1]: total_profit = 14, distinct_categories = 3, elegance = 14 + 3² = 23.

Example 3 — All Same Category

$ Input: items = [[1,1],[2,1],[3,1]], k = 2

› Output: 6

💡 Note: All items have the same category. Best selection is [2,1] and [3,1]: total_profit = 5, distinct_categories = 1, elegance = 5 + 1² = 6.

Constraints

1 ≤ items.length ≤ 10⁵
items[i].length == 2
1 ≤ items[i][0], items[i][1] ≤ 10⁹
1 ≤ k ≤ items.length

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

The key insight is balancing profit with category diversity since the diversity bonus is squared. The greedy approach sorts by profit and uses stack-based optimization to replace duplicates with new categories. Time: O(n log n), Space: O(n).

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(C(n,k) × k) Space: O(k)

Generate every possible combination of k items from the array, calculate the elegance (total profit + distinct categories²) for each combination, and return the maximum.

Greedy with Stack Optimization

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

Sort items by profit in descending order, take the top k items as the initial selection. Then try to replace duplicate category items with unused categories to maximize the category diversity bonus.

Brute Force - Try All Combinations — Algorithm Steps

Generate all C(n,k) combinations of k items
For each combination, calculate total profit and count distinct categories
Calculate elegance = total_profit + distinct_categories²
Return maximum elegance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible ways to choose k items

Calculate Elegance

For each combination: profit + categories²

Find Maximum

Return the highest elegance value

Code -

solution.c — C

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

long long maxElegance = 0;

void generateCombinations(int items[][2], int n, int k, int start, int* combo, int comboSize) {
    if (comboSize == k) {
        long long totalProfit = 0;
        bool categories[1001] = {false}; // Assuming categories are reasonable
        int distinctCount = 0;
        
        for (int i = 0; i < k; i++) {
            int idx = combo[i];
            totalProfit += items[idx][0];
            if (!categories[items[idx][1]]) {
                categories[items[idx][1]] = true;
                distinctCount++;
            }
        }
        
        long long elegance = totalProfit + (long long)distinctCount * distinctCount;
        if (elegance > maxElegance) {
            maxElegance = elegance;
        }
        return;
    }
    
    for (int i = start; i < n; i++) {
        combo[comboSize] = i;
        generateCombinations(items, n, k, i + 1, combo, comboSize + 1);
    }
}

long long solution(int items[][2], int n, int k) {
    maxElegance = 0;
    int* combo = (int*)malloc(k * sizeof(int));
    generateCombinations(items, n, k, 0, combo, 0);
    free(combo);
    return maxElegance;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for 2D array
    int items[100][2];
    int n = 0;
    
    char* ptr = line + 1; // Skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            items[n][0] = strtol(ptr, &ptr, 10);
            ptr++; // Skip comma
            items[n][1] = strtol(ptr, &ptr, 10);
            n++;
            while (*ptr && *ptr != ']') ptr++;
            if (*ptr) ptr++;
        } else {
            ptr++;
        }
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%lld\n", solution(items, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n,k) × k)

Generate C(n,k) combinations, each taking O(k) time to process

✓ Linear Growth

Space Complexity

O(k)

Space for storing current combination and category set

✓ Linear Space

15.2K Views

Medium Frequency

~35 min Avg. Time

423 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 Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler