Maximum Spending After Buying Items

Maximum Spending After Buying Items - Problem

You are given a 0-indexed m × n integer matrix values, representing the values of m × n different items in m different shops. Each shop has n items where the j^th item in the i^th shop has a value of values[i][j].

Additionally, the items in the i^th shop are sorted in non-increasing order of value. That is, values[i][j] >= values[i][j + 1] for all 0 <= j < n - 1.

On each day, you would like to buy a single item from one of the shops. Specifically, on the d^th day you can:

Pick any shop i
Buy the rightmost available item j for the price of values[i][j] × d

That is, find the greatest index j such that item j was never bought before, and buy it for the price of values[i][j] × d.

Note that all items are pairwise different. For example, if you have bought item 0 from shop 1, you can still buy item 0 from any other shop.

Return the maximum amount of money that can be spent on buying all m × n products.

Input & Output

Example 1 — Basic 2×2 Matrix

$ Input: values = [[8,5],[9,4]]

› Output: 74

💡 Note: Items available: 8,5,9,4. Optimal strategy: buy smallest items first to save larger values for later days with higher multipliers. Day 1: buy 4×1=4, Day 2: buy 5×2=10, Day 3: buy 8×3=24, Day 4: buy 9×4=36. Total: 4+10+24+36=74

Example 2 — Single Row

$ Input: values = [[10,8,6,4,2]]

› Output: 110

💡 Note: One shop with 5 items in decreasing order. Buy in reverse order: Day 1: buy 2×1=2, Day 2: buy 4×2=8, Day 3: buy 6×3=18, Day 4: buy 8×4=32, Day 5: buy 10×5=50. Total: 2+8+18+32+50=110

Example 3 — Single Column

$ Input: values = [[5],[3],[4]]

› Output: 26

💡 Note: Three shops with one item each: 5,3,4. Sort: [3,4,5]. Day 1: buy 3×1=3, Day 2: buy 4×2=8, Day 3: buy 5×3=15. Total: 3+8+15=26

Constraints

1 ≤ m, n ≤ 1000
1 ≤ values[i][j] ≤ 10⁶
values[i][j] ≥ values[i][j + 1] for all valid i, j

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Meta 18

The key insight is to buy items with smallest values first so that expensive items get multiplied by larger day numbers. Best approach is sort all items then buy in ascending order. Time: O(m×n×log(m×n)), Space: O(m×n)

Common Approaches

✓ Brute Force - Try All Sequences

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

For each day, try buying from each available position in each shop, recursively explore all possibilities, and return the maximum total spending achieved.

Greedy - Min Heap Approach

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

Extract all items into a list with their shop/position info, use a min-heap to always select the item with minimum value, and buy it on the current day. This ensures expensive items are bought on later days with higher multipliers.

Sort All Items

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

Flatten the 2D matrix into a single array containing all item values, sort this array in ascending order, then iterate through buying each item on consecutive days starting from day 1.

Brute Force - Try All Sequences — Algorithm Steps

Step 1: For each day, iterate through all shops and their available rightmost items
Step 2: Recursively try buying each item and explore remaining days
Step 3: Return the maximum total spending among all sequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Day 1

Try buying each available item from any shop

Recurse

For each choice, recursively solve remaining days

Maximum

Return the sequence with highest total spending

Code -

solution.c — C

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

#define MAX_ITEMS 1000

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 compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

long long solution(int all_items[], int num_items) {
    // Sort items in ascending order (buy cheapest first)
    qsort(all_items, num_items, sizeof(int), compare);
    
    // Calculate total spending
    long long total = 0;
    for (int day = 1; day <= num_items; day++) {
        total += (long long)all_items[day - 1] * day;
    }
    
    return total;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int all_items[MAX_ITEMS];
    int num_items = 0;
    
    // Parse input and collect all items from all shops
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (*p == '[') {
            // Parse inner array
            int temp_items[100];
            int temp_size;
            parseArray(p, temp_items, &temp_size);
            
            for (int i = 0; i < temp_size; i++) {
                all_items[num_items++] = temp_items[i];
            }
            
            // Skip to after this array
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
        } else {
            p++;
        }
    }
    
    printf("%lld\n", solution(all_items, num_items));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((m×n)!)

For each day we have up to m×n choices, leading to factorial time complexity

✓ Linear Growth

Space Complexity

O(m×n)

Recursion depth is m×n levels deep, plus space to track purchased items

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

847 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 Sequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler