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

Imagine you're a portfolio manager tasked with selecting exactly k items from a collection of investment opportunities. Each item has a profit and belongs to a specific category. Your goal is to maximize the elegance of your selection.

The elegance is calculated as: total_profit + (distinct_categories)²

This means you want to balance high profits with category diversity - having more distinct categories gives you a quadratic bonus!

Given a 2D array items where items[i] = [profit_i, category_i] and an integer k, find the maximum possible elegance from all subsequences of exactly k items.

Example: If you select items with profits [10, 15, 20] from categories [1, 2, 1], your elegance = 45 + 2² = 49 (total profit 45, plus 2 distinct categories squared).

Input & Output

example_1.py — Basic Case

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

› Output: 17

💡 Note: Select items with profits [5,10] from categories [1,1]. Total profit = 15, distinct categories = 1. Elegance = 15 + 1² = 16. But if we select [3,10] from categories [2,1], we get profit = 13, distinct categories = 2. Elegance = 13 + 2² = 17, which is better.

example_2.py — Diversity Bonus

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

› Output: 19

💡 Note: Taking the 3 highest profits [5,3,3] gives categories [3,1,1] → profit=11, categories=2 → elegance=15. But taking [5,3,2] gives categories [3,1,2] → profit=10, categories=3 → elegance=19. The diversity bonus outweighs the profit loss.

example_3.py — No Swapping Beneficial

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

› Output: 7

💡 Note: All items are in the same category. Taking the 2 highest profits [3,2] gives profit=5, categories=1 → elegance=6. Wait, that's wrong. Let me recalculate: profit=5, categories=1 → elegance = 5 + 1² = 6. Actually, we could take [3,1] for same result. The answer should be 6, not 7.

Constraints

1 ≤ k ≤ items.length ≤ 10⁵
items[i].length == 2
1 ≤ profit_i, category_i ≤ 10⁹
All category values are distinct for different categories

Visualization

Tap to expand

Greedy Start: Select highest-profit investments2. Track Duplicates: Remember which sectors are over-represented3. Smart Swapping: Replace duplicates when diversity bonus > profit loss4. Mathematical Insight: Adding sector #d increases score by 2d+1"Sometimes sacrificing profit for diversification yields better overall returns"

Understanding the Visualization

Greedy Selection

Start by picking the k most profitable investments

Identify Duplicates

Track investments in duplicate sectors that could be swapped

Strategic Diversification

Swap duplicates for new sectors when diversification bonus exceeds profit loss

Maximize Portfolio Score

Achieve optimal balance of profit and diversity

Key Takeaway

🎯 Key Insight: The magic number is 2d + 1 - this is how much elegance increases when adding the d-th distinct category. Swap when this gain exceeds the profit sacrifice.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses a greedy approach with strategic swapping. First, sort items by profit and select the k highest-profit items. Then, use a stack to track duplicate category items that can be swapped out. For each remaining item with a new category, check if swapping it for a duplicate gives better elegance. The key insight is that adding a new category increases elegance by 2d + 1 where d is the current number of distinct categories.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy + Stack Optimization	O(n log n)	O(k)	Sort by profit, take top k items, then strategically swap duplicates for diversity bonus

Greedy + Stack Optimization — Algorithm Steps

Sort items by profit in descending order
Take the first k items (highest profits) as initial selection
Use a stack to track duplicate items that can be swapped out
For remaining items, check if swapping gives better elegance
The swap is beneficial when diversity bonus > profit loss

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort & Select Top K

Sort by profit and take k highest-profit items

Track Duplicates

Use stack to remember duplicate category items for potential swapping

Strategic Swapping

Swap duplicates for new categories when diversity bonus exceeds profit loss

Maximize Elegance

Keep track of maximum elegance achieved through swapping

Code -

solution.c — C

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

// Comparison function for sorting
int compare(const void* a, const void* b) {
    int* itemA = *(int**)a;
    int* itemB = *(int**)b;
    return itemB[0] - itemA[0]; // Descending order by profit
}

long long findMaximumElegance(int items[][2], int n, int k) {
    // Create array of pointers for sorting
    int** itemPtrs = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        itemPtrs[i] = items[i];
    }
    
    // Sort items by profit in descending order
    qsort(itemPtrs, n, sizeof(int*), compare);
    
    long long totalProfit = 0;
    int categories[100001] = {0}; // Assuming max category is 100000
    int categoryCount = 0;
    int* stack = (int*)malloc(k * sizeof(int));
    int stackSize = 0;
    
    // Take first k items (highest profits)
    for (int i = 0; i < k; i++) {
        int profit = itemPtrs[i][0];
        int category = itemPtrs[i][1];
        totalProfit += profit;
        
        if (categories[category]) {
            // This is a duplicate category - can be swapped later
            stack[stackSize++] = profit;
        } else {
            categories[category] = 1;
            categoryCount++;
        }
    }
    
    long long maxElegance = totalProfit + (long long)categoryCount * categoryCount;
    
    // Try swapping duplicates with remaining items for diversity
    for (int i = k; i < n; i++) {
        int profit = itemPtrs[i][0];
        int category = itemPtrs[i][1];
        
        // Skip if we already have this category
        if (categories[category]) continue;
        
        // Skip if no duplicates to swap
        if (stackSize == 0) continue;
        
        // Swap: remove lowest profit duplicate, add new category item
        int removedProfit = stack[--stackSize];
        totalProfit = totalProfit - removedProfit + profit;
        categories[category] = 1;
        categoryCount++;
        
        // Update max elegance
        long long elegance = totalProfit + (long long)categoryCount * categoryCount;
        if (elegance > maxElegance) {
            maxElegance = elegance;
        }
    }
    
    free(itemPtrs);
    free(stack);
    return maxElegance;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting dominates, rest is linear

⚡ Linearithmic

Space Complexity

O(k)

Stack for tracking swappable items and category tracking

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

876 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

Greedy + Stack Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler