Maximum Spending After Buying Items - Practice Coding Problems

Maximum Spending After Buying Items - Problem

Welcome to the Strategic Shopping Challenge! 🛍️

You're managing purchases across multiple shops over several days, and each day your budget multiplier increases. Your goal is to maximize your total spending by making smart choices about when and where to buy items.

The Setup:

You have m shops, each with n items
Items in each shop are sorted by value in decreasing order (most expensive first)
Each day d, you can only buy the rightmost available item from any shop
The price you pay is item_value × day_number

The Challenge: Since later days have higher multipliers, you want to save your most valuable items for those days. But you can only access the rightmost (least valuable remaining) item from each shop each day.

Given a matrix values[i][j] representing item values, return the maximum total amount you can spend buying all m × n items over m × n days.

Input & Output

example_1.py — Basic Case

$ Input: values = [[8,5,2],[6,4,1],[9,7,3]]

› Output: 285

💡 Note: Day 1: Buy item with value 1 (from shop 2), spending = 1×1 = 1. Day 2: Buy item with value 2 (from shop 1), spending = 2×2 = 4. Day 3: Buy item with value 3 (from shop 3), spending = 3×3 = 9. Continue this pattern, always buying the cheapest available item to save expensive items for later days with higher multipliers.

example_2.py — Single Shop

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

› Output: 110

💡 Note: Only one shop with 5 items. We must buy them in order from right to left: Day 1: 2×1=2, Day 2: 4×2=8, Day 3: 6×3=18, Day 4: 8×4=32, Day 5: 10×5=50. Total = 2+8+18+32+50 = 110.

example_3.py — Equal Values

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

› Output: 40

💡 Note: All items have the same value (5), so the order doesn't matter for optimization. Total spending = 5×1 + 5×2 + 5×3 + 5×4 = 5×(1+2+3+4) = 5×10 = 50. Wait, let me recalculate: 5×1 + 5×2 + 5×3 + 5×4 = 5 + 10 + 15 + 20 = 50.

Constraints

1 ≤ m ≤ 10³
1 ≤ n ≤ 10⁴
1 ≤ values[i][j] ≤ 10⁶
values[i] is sorted in non-increasing order
m × n ≤ 10⁵

Visualization

Tap to expand

Understanding the Visualization

Setup Min-Heap

Add the rightmost (cheapest) item from each shop to a min-heap

Daily Purchases

Each day, buy the globally cheapest available item (heap top)

Replenish Options

When buying from a shop, add that shop's next item to the heap

Maximize Spending

Cheap items × low days, expensive items × high days = maximum total

Key Takeaway

🎯 Key Insight: The greedy strategy of always buying the cheapest available item maximizes total spending because it saves expensive items for days with higher multipliers.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a greedy approach with a min-heap. Since day multipliers increase, we want to buy cheaper items early and expensive items late. The min-heap always gives us the cheapest available item across all shops, ensuring maximum total spending in O(mn log m) time.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with Priority Queue (Optimal)	O(mn log m)	O(m)	Use min-heap to always buy the cheapest available item each day
Brute Force (Try All Combinations)	O(m^(m×n))	O(m×n)	Try every possible sequence of shop selections using recursion

Greedy with Priority Queue (Optimal) — Algorithm Steps

Create a min-heap with the rightmost item from each shop
For each day from 1 to m×n:
Extract the minimum item value from the heap
Add value × day to total spending
If the shop has more items, add the next item to heap
Return total spending

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Heap

Add rightmost item from each shop to min-heap

Day-by-Day Selection

Extract minimum, calculate spending, add next item if available

Optimal Result

Greedy choice leads to maximum total spending

Code -

solution.c — C

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

typedef struct {
    int value;
    int shop;
    int index;
} Item;

typedef struct {
    Item* items;
    int size;
    int capacity;
} MinHeap;

MinHeap* createHeap(int capacity) {
    MinHeap* heap = malloc(sizeof(MinHeap));
    heap->items = malloc(capacity * sizeof(Item));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void heapifyUp(MinHeap* heap, int index) {
    while (index > 0) {
        int parent = (index - 1) / 2;
        if (heap->items[parent].value <= heap->items[index].value) break;
        
        Item temp = heap->items[parent];
        heap->items[parent] = heap->items[index];
        heap->items[index] = temp;
        index = parent;
    }
}

void heapifyDown(MinHeap* heap, int index) {
    while (1) {
        int minIndex = index;
        int left = 2 * index + 1;
        int right = 2 * index + 2;
        
        if (left < heap->size && heap->items[left].value < heap->items[minIndex].value) {
            minIndex = left;
        }
        if (right < heap->size && heap->items[right].value < heap->items[minIndex].value) {
            minIndex = right;
        }
        
        if (minIndex == index) break;
        
        Item temp = heap->items[index];
        heap->items[index] = heap->items[minIndex];
        heap->items[minIndex] = temp;
        index = minIndex;
    }
}

void push(MinHeap* heap, Item item) {
    heap->items[heap->size] = item;
    heapifyUp(heap, heap->size);
    heap->size++;
}

Item pop(MinHeap* heap) {
    Item min = heap->items[0];
    heap->items[0] = heap->items[heap->size - 1];
    heap->size--;
    heapifyDown(heap, 0);
    return min;
}

long long maxSpending(int** values, int m, int n) {
    MinHeap* heap = createHeap(m);
    
    for (int shop = 0; shop < m; shop++) {
        Item item = {values[shop][n-1], shop, n-1};
        push(heap, item);
    }
    
    long long totalSpending = 0;
    
    for (int day = 1; day <= m * n; day++) {
        Item current = pop(heap);
        totalSpending += (long long) current.value * day;
        
        if (current.index > 0) {
            Item next = {values[current.shop][current.index-1], current.shop, current.index-1};
            push(heap, next);
        }
    }
    
    free(heap->items);
    free(heap);
    return totalSpending;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(mn log m)

We process mn items, each heap operation takes O(log m) time

⚡ Linearithmic

Space Complexity

O(m)

Heap stores at most m items (one from each shop)

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

842 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 with Priority Queue (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler