Maximum Sum With at Most K Elements - Practice Coding Problems

Maximum Sum With at Most K Elements - Problem

Imagine you're a treasure hunter with a magical bag that can hold at most k precious gems. You've discovered an ancient temple with a grid of gem chambers, where each chamber contains gems of different values.

However, there's a catch! Each row of chambers has a guardian that limits how many gems you can take from that row. The i-th row's guardian allows you to take at most limits[i] gems from that entire row.

Your mission: Select at most k gems from the entire grid to maximize their total value, while respecting each row's guardian limits.

Input:
• A 2D matrix grid of size n × m containing gem values
• An array limits of length n specifying max gems per row
• An integer k representing your bag capacity

Output: The maximum possible sum of gem values you can collect.

Input & Output

example_1.py — Basic Case

$ Input: grid = [[1,2,3],[4,5,6]], limits = [1,2], k = 3

› Output: 15

💡 Note: We can take element 6 from row 1 (1 element), elements 5 and 4 from row 1 (2 elements total from row 1), giving us sum = 6 + 5 + 4 = 15. This respects limits[0]=1 (we took 0 from row 0) and limits[1]=2 (we took 2 from row 1), and we took k=3 elements total.

example_2.py — K Constraint Binding

$ Input: grid = [[7,8,9],[1,2,3]], limits = [3,3], k = 2

› Output: 17

💡 Note: Even though we could take up to 3 elements from each row, we're limited by k=2. We take the two highest values: 9 and 8, both from row 0, giving sum = 9 + 8 = 17.

example_3.py — Row Limit Binding

$ Input: grid = [[10,1],[2,3]], limits = [1,1], k = 3

› Output: 13

💡 Note: We want to take 3 elements but each row allows only 1. We take the best element from each row: 10 from row 0 and 3 from row 1, giving sum = 10 + 3 = 13. We can only take 2 elements total due to row limits.

Constraints

1 ≤ n, m ≤ 10³
1 ≤ grid[i][j] ≤ 10⁴
0 ≤ limits[i] ≤ m
1 ≤ k ≤ n × m
Sum of all limits[i] ≥ k is not guaranteed

Visualization

Tap to expand

Understanding the Visualization

Survey the Vault

Examine all gems and sort them by value from highest to lowest

Greedy Selection

Start with the most valuable gem and work your way down

Check Guardian Limits

Before taking each gem, verify the row guardian allows it

Monitor Bag Capacity

Stop when your bag reaches capacity k or no more valid gems exist

Key Takeaway

🎯 Key Insight: Greedy selection works because we can always replace a lower-value gem with a higher-value one if constraints allow, making the sorted approach optimal!

Asked in

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

The optimal solution uses a greedy approach with sorting. We flatten the 2D grid, sort all elements by value in descending order, then greedily select the highest-value elements while respecting both the per-row limits and the total capacity k. This works because if we can afford a lower-value element, we can always replace it with a higher-value one without violating constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Combinations)	O(2^(n*m))	O(n*m)	Try every possible combination of elements respecting row limits
Greedy with Sorting (Optimal)	O(nm log(nm))	O(nm)	Sort all elements by value and greedily select the highest values while respecting constraints

Brute Force (Generate All Combinations) — Algorithm Steps

Generate all possible subsets of elements from the grid
For each subset, check if it violates any row limits
Check if subset size exceeds k
If valid, calculate sum and update maximum
Return the maximum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at first element

Begin recursive exploration from grid[0][0]

Make binary choice

For each element, decide to take it or skip it

Check constraints

Verify row limits and total k constraint

Track maximum

Update global maximum whenever we find a better solution

Code -

solution.c — C

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

int maxSum = 0;

void backtrack(int** grid, int* limits, int k, int n, int m,
               int row, int col, int currentSum, int taken, int* rowCounts) {
    if (taken > k) return;
    
    if (currentSum > maxSum) {
        maxSum = currentSum;
    }
    
    if (row >= n) return;
    
    int nextRow = col + 1 < m ? row : row + 1;
    int nextCol = col + 1 < m ? col + 1 : 0;
    
    // Don't take current element
    backtrack(grid, limits, k, n, m, nextRow, nextCol, currentSum, taken, rowCounts);
    
    // Take current element if possible
    if (rowCounts[row] < limits[row] && taken < k) {
        rowCounts[row]++;
        backtrack(grid, limits, k, n, m, nextRow, nextCol, 
                 currentSum + grid[row][col], taken + 1, rowCounts);
        rowCounts[row]--;
    }
}

int solve(int** grid, int* limits, int k, int n, int m) {
    maxSum = 0;
    int* rowCounts = (int*)calloc(n, sizeof(int));
    backtrack(grid, limits, k, n, m, 0, 0, 0, 0, rowCounts);
    free(rowCounts);
    return maxSum;
}

int main() {
    // Input parsing and solve call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n*m))

We potentially explore every subset of the n*m elements in the grid

✓ Linear Growth

Space Complexity

O(n*m)

Recursion stack can go as deep as the total number of elements

⚡ Linearithmic Space

42.4K Views

Medium-High Frequency

~18 min Avg. Time

1.8K 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 (Generate All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler