Maximum Sum With at Most K Elements

Maximum Sum With at Most K Elements - Problem

You are given a 2D integer matrix grid of size n × m, an integer array limits of length n, and an integer k.

The task is to find the maximum sum of at most k elements from the matrix grid such that:

The number of elements taken from the i^th row of grid does not exceed limits[i].

Return the maximum sum.

Input & Output

Example 1 — Basic Case

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

› Output: 6

💡 Note: Take the largest possible elements: 4 from row 1 and 2 from row 0 (since limit allows only 1 element per row). Sum = 4 + 2 = 6

Example 2 — Higher Limits

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

› Output: 10

💡 Note: Sorted elements: [5,3,2,1]. Take 5 (row 0), 3 (row 1), 2 (row 0). Sum = 5 + 3 + 2 = 10

Example 3 — Limited by k

$ Input: grid = [[10,8],[6,4]], limits = [2,2], k = 1

› Output: 10

💡 Note: Even though limits allow taking more elements, k=1 limits us to just one element. Take the maximum: 10

Constraints

1 ≤ n, m ≤ 100
1 ≤ k ≤ n × m
0 ≤ limits[i] ≤ m
-1000 ≤ grid[i][j] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use a greedy approach: sort all elements by value in descending order, then select the largest elements while respecting row limits. The optimal approach is Greedy with Sorting: Time O(n×m×log(n×m)), Space O(n×m).

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2^(n×m)) Space: O(k)

Try every possible way to select at most k elements from the matrix while respecting the limit for each row. Use backtracking to explore all valid combinations and track the maximum sum.

Greedy with Priority Queue

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

Collect all elements with their row information, sort by value in descending order, then greedily select the k largest elements while respecting row limits using a priority queue approach.

Max Heap Optimization

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

Build a max heap of all elements, then repeatedly extract the maximum element while maintaining row limit constraints. This approach is more memory efficient for large sparse matrices.

Brute Force - Try All Combinations — Algorithm Steps

Generate all valid combinations using backtracking
For each combination, check if it respects row limits
Track the maximum sum among all valid combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with empty selection

Explore

Try adding each valid element

Backtrack

Remove element and try next option

Code -

solution.c — C

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

typedef struct {
    int value;
    int row;
} Element;

int compare(const void* a, const void* b) {
    Element* elemA = (Element*)a;
    Element* elemB = (Element*)b;
    return elemB->value - elemA->value; // descending order
}

void parseGrid(const char* str, int** grid, int* rows, int* cols) {
    // Count rows and cols
    *rows = 0;
    *cols = 0;
    const char* p = str;
    while (*p) {
        if (*p == '[' && *(p+1) != '[') (*rows)++;
        p++;
    }
    
    // Count columns from first row
    p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        (*cols)++;
        while (*p && *p != ',' && *p != ']') p++;
    }
    
    // Allocate grid
    *grid = (int*)malloc((*rows) * (*cols) * sizeof(int));
    
    // Parse values
    int idx = 0;
    p = str;
    while (*p) {
        if (*p == '-' || (*p >= '0' && *p <= '9')) {
            (*grid)[idx++] = (int)strtol(p, (char**)&p, 10);
        } else {
            p++;
        }
    }
}

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 solution(int* grid, int* limits, int rows, int cols, int k) {
    int n = rows, m = cols;
    
    // Create list of (value, row) for all elements
    Element* elements = (Element*)malloc(n * m * sizeof(Element));
    int elemCount = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            elements[elemCount].value = grid[i * m + j];
            elements[elemCount].row = i;
            elemCount++;
        }
    }
    
    // Sort by value in descending order
    qsort(elements, elemCount, sizeof(Element), compare);
    
    // Greedily pick elements
    int* rowCounts = (int*)calloc(n, sizeof(int));
    int totalSum = 0;
    int selected = 0;
    
    for (int i = 0; i < elemCount; i++) {
        if (selected >= k) {
            break;
        }
        if (rowCounts[elements[i].row] < limits[elements[i].row]) {
            totalSum += elements[i].value;
            rowCounts[elements[i].row] += 1;
            selected += 1;
        }
    }
    
    free(elements);
    free(rowCounts);
    return totalSum;
}

int main() {
    char line[10000];
    
    // Read grid
    fgets(line, sizeof(line), stdin);
    int* grid;
    int rows, cols;
    parseGrid(line, &grid, &rows, &cols);
    
    // Read limits
    fgets(line, sizeof(line), stdin);
    int limits[100];
    int limitSize;
    parseArray(line, limits, &limitSize);
    
    // Read k
    fgets(line, sizeof(line), stdin);
    int k = atoi(line);
    
    printf("%d\n", solution(grid, limits, rows, cols, k));
    
    free(grid);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n×m))

Each element can be included or excluded, leading to exponential combinations

⚡ Linearithmic

Space Complexity

O(k)

Recursion stack depth is at most k levels deep

⚡ Linearithmic Space

8.9K Views

Medium Frequency

~15 min Avg. Time

234 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