Shopping Offers - Practice Coding Problems

Shopping Offers - Problem

Array Dynamic Programming Backtracking Bit Manipulation Memoization Bitmask Medium

Welcome to the LeetCode Store! 🛍️ You're shopping for multiple items, and there are some fantastic bundle deals available that could save you money.

Here's what you need to figure out: What's the minimum amount you need to pay to buy exactly the items you want?

You're given:

price[] - Regular price of each item
needs[] - How many of each item you want to buy
special[] - Bundle offers where each offer contains [item1_qty, item2_qty, ..., bundle_price]

Rules:

You can use any special offer multiple times
You cannot buy more items than you need (even if it's cheaper)
You want to minimize the total cost

Example: If you need [2,5] items with prices [2,5] and there's a special offer [3,0,5], you could buy the bundle once and pay regular price for remaining items.

Input & Output

example_1.py — Basic Shopping

$ Input: price = [2,5], special = [[3,0,5],[1,2,10]], needs = [3,2]

› Output: 14

💡 Note: We need 3 units of item 0 and 2 units of item 1. Use special offer [3,0,5] once (costs 5), then buy 2 units of item 1 individually (costs 2*5=10). Total: 5+10=15. Or use offer [1,2,10] twice (costs 20), then buy 1 unit of item 0 (costs 2). Total: 20+2=22. The minimum is 14 using the first offer once and buying remaining items individually: 5 + 2*0 + 2*5 = 15. Wait, let me recalculate: Use offer [3,0,5] for 5, then need [0,2] items, cost 0*2 + 2*5 = 10, total 15. Actually optimal is: use [1,2,10] once for 10, then need [2,0], cost 2*2 + 0*5 = 4, total 14.

example_2.py — Individual Better

$ Input: price = [2,3,4], special = [[1,1,0,4],[2,2,1,9]], needs = [1,2,1]

› Output: 11

💡 Note: We need [1,2,1] items with prices [2,3,4]. Check special offers: [1,1,0,4] gives 1 of items 0&1 for 4 (saves 2+3-4=1), [2,2,1,9] gives [2,2,1] for 9 (regular cost is 2*2+2*3+1*4=14, saves 5). We can use first offer once, leaving needs [0,1,1], then buy individually: 4 + 0*2 + 1*3 + 1*4 = 11.

example_3.py — Edge Case Empty

$ Input: price = [2,5], special = [[3,0,5],[1,2,10]], needs = [0,0]

› Output: 0

💡 Note: We don't need any items, so the cost is 0. No special offers are used.

Visualization

Tap to expand

Understanding the Visualization

Analyze Your List

Start with your needs: [3,2] items at prices [2,5] each

Check Bundle Deals

Available offers: [3,0,5] and [1,2,10] - which combinations work?

Calculate All Options

Try each valid offer combination and compare with individual purchases

Cache Results

Remember the best cost for each shopping state to avoid recalculation

Key Takeaway

🎯 Key Insight: By caching the minimum cost for each shopping state (combination of remaining needs), we avoid recalculating the same subproblems and achieve optimal performance while exploring all valid purchase combinations.

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Where k is max items needed and n is number of item types, but each unique state calculated only once

✓ Linear Growth

Space Complexity

O(k^n)

Space for memoization cache storing results for each unique needs state

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 6
0 ≤ price[i] ≤ 1000
1 ≤ len(special) ≤ 100
special[i].length = n + 1
0 ≤ special[i][j] ≤ 50
0 ≤ needs[i] ≤ 10²
Each special offer must provide savings (otherwise it can be ignored)

Asked in

A Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 18

The optimal approach uses dynamic programming with memoization to avoid recalculating the same shopping states. For each combination of remaining needs, we try all valid special offers and compare with buying items individually, caching results for O(k^n) time and space complexity where k is max items needed and n is number of item types.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization (Optimal)	O(k^n)	O(k^n)	Cache results for each shopping state to avoid recalculating the same subproblems
Brute Force (Try All Combinations)	O(k^n)	O(n)	Recursively try all possible ways to use special offers and individual purchases

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Use a hash map to cache results for each needs state
Convert needs array to string/tuple for hashing
Before calculating, check if result already cached
After calculating, store result in cache
Return cached or calculated minimum cost

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate [2,5] state

First time seeing this state, calculate minimum cost

Cache result

Store result in memo table: memo['2,5'] = 29

Encounter [2,5] again

If we see this state again, return cached value instantly

Build up solution

Use cached subproblems to solve larger problems efficiently

Code -

solution.c — C

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

#define MAX_STATES 10000

typedef struct {
    char key[100];
    int value;
} MemoEntry;

MemoEntry memo[MAX_STATES];
int memoSize = 0;

void createKey(int* needs, int needsSize, char* key) {
    key[0] = '\0';
    for (int i = 0; i < needsSize; i++) {
        char temp[10];
        sprintf(temp, "%d,", needs[i]);
        strcat(key, temp);
    }
}

int findMemo(char* key) {
    for (int i = 0; i < memoSize; i++) {
        if (strcmp(memo[i].key, key) == 0) {
            return memo[i].value;
        }
    }
    return -1;
}

void addMemo(char* key, int value) {
    strcpy(memo[memoSize].key, key);
    memo[memoSize].value = value;
    memoSize++;
}

int dfs(int* price, int** special, int specialSize, int* specialColSize, int* needs, int needsSize) {
    char key[100];
    createKey(needs, needsSize, key);
    
    int cached = findMemo(key);
    if (cached != -1) {
        return cached;
    }
    
    // Base case: buy all remaining items individually
    int minCost = 0;
    for (int i = 0; i < needsSize; i++) {
        minCost += needs[i] * price[i];
    }
    
    // Try each special offer
    for (int s = 0; s < specialSize; s++) {
        // Check if we can use this offer
        int canUse = 1;
        for (int i = 0; i < needsSize; i++) {
            if (special[s][i] > needs[i]) {
                canUse = 0;
                break;
            }
        }
        
        if (canUse) {
            // Use the offer and recurse
            int* newNeeds = (int*)malloc(needsSize * sizeof(int));
            for (int i = 0; i < needsSize; i++) {
                newNeeds[i] = needs[i] - special[s][i];
            }
            int costWithOffer = special[s][needsSize] + dfs(price, special, specialSize, specialColSize, newNeeds, needsSize);
            if (costWithOffer < minCost) {
                minCost = costWithOffer;
            }
            free(newNeeds);
        }
    }
    
    addMemo(key, minCost);
    return minCost;
}

int shoppingOffers(int* price, int priceSize, int** special, int specialSize, int* specialColSize, int* needs, int needsSize) {
    memoSize = 0;
    return dfs(price, special, specialSize, specialColSize, needs, needsSize);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

Where k is max items needed and n is number of item types, but each unique state calculated only once

✓ Linear Growth

Space Complexity

O(k^n)

Space for memoization cache storing results for each unique needs state

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 6
0 ≤ price[i] ≤ 1000
1 ≤ len(special) ≤ 100
special[i].length = n + 1
0 ≤ special[i][j] ≤ 50
0 ≤ needs[i] ≤ 10²
Each special offer must provide savings (otherwise it can be ignored)

38.6K Views

Medium Frequency

~25 min Avg. Time

1.3K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler