Maximize Items - Practice Coding Problems

Maximize Items - Problem

Database Hard

You're the warehouse manager for LeetCode's fulfillment center, and you have a challenging optimization problem! Your warehouse has exactly 500,000 square feet of storage space, and you need to maximize the number of items you can stock.

Here's the twist: LeetCode prioritizes prime-eligible items to keep customers happy. Your strategy must be:

First: Stock as many prime-eligible items as possible
Then: Use remaining space for non-prime items to maximize total item count

You're given an Inventory table with item details:

Column Name	Type
item_id	int
item_type	varchar
item_category	varchar
square_footage	decimal

The item_type indicates whether items are "prime_eligible" or "not_prime".

Goal: Return the maximum number of items for each type, ordered by count (descending). If no non-prime items fit, output 0 for that category.

Input & Output

example_1.sql — Basic Warehouse Optimization

$ Input: Inventory Table: | item_id | item_type | item_category | square_footage | |---------|-----------|---------------|----------------| | 1 | prime_eligible | electronics | 100.00 | | 2 | prime_eligible | electronics | 100.00 | | 3 | not_prime | clothing | 50.00 | | 4 | not_prime | clothing | 50.00 | | 5 | not_prime | clothing | 50.00 |

› Output: | item_type | item_count | |-----------|------------| | prime_eligible | 5000 | | not_prime | 0 |

💡 Note: Prime items average 100 sq ft each, so we can fit 5000 prime items (500,000 ÷ 100). This uses all 500,000 sq ft, leaving no space for non-prime items.

example_2.sql — Mixed Inventory Scenario

$ Input: Inventory Table: | item_id | item_type | item_category | square_footage | |---------|-----------|---------------|----------------| | 1 | prime_eligible | books | 200.00 | | 2 | prime_eligible | books | 200.00 | | 3 | not_prime | toys | 100.00 | | 4 | not_prime | toys | 100.00 |

› Output: | item_type | item_count | |-----------|------------| | not_prime | 1000 | | prime_eligible | 2500 |

💡 Note: Prime items need 200 sq ft each: 2500 items use 500,000 sq ft. Since this fills the warehouse, remaining space is 0, so 0 non-prime items fit. Wait - let me recalculate: 2500 × 200 = 500,000 exactly, so 1000 non-prime items actually indicates 2500 prime items use less space.

example_3.sql — No Prime Items Edge Case

$ Input: Inventory Table: | item_id | item_type | item_category | square_footage | |---------|-----------|---------------|----------------| | 1 | not_prime | furniture | 250.00 | | 2 | not_prime | furniture | 250.00 | | 3 | not_prime | appliances | 250.00 |

› Output: | item_type | item_count | |-----------|------------| | not_prime | 2000 | | prime_eligible | 0 |

💡 Note: No prime items available. Non-prime items average 250 sq ft each, so maximum is 500,000 ÷ 250 = 2000 items. Prime count shows 0 since no prime items exist.

Constraints

1 ≤ item_id ≤ 10⁶
item_type ∈ {'prime_eligible', 'not_prime'}
1.00 ≤ square_footage ≤ 1000.00
Total warehouse capacity = 500,000 square feet
Item counts must be integers (use FLOOR function)
If not_prime count is 0, still include it in output

Visualization

Tap to expand

constrained knapsack problem - maximize items with priority constraintGreedy approach works because we prioritize by business rules, not just efficiencyTime: O(n) | Space: O(1) - Single pass with constant extra storage

Understanding the Visualization

Measure Package Sizes

Calculate average space needed for Prime and Regular packages

Fill Prime Packages First

Pack maximum Prime packages (they have priority!)

Calculate Leftover Space

Determine remaining warehouse capacity

Pack Regular Packages

Fill remaining space with Regular packages

Report Results

Count packages by priority, highest count first

Key Takeaway

🎯 Key Insight: This warehouse optimization problem is actually a two-stage greedy knapsack where business priorities (Prime first) override pure efficiency optimization. The greedy approach works perfectly because the constraint hierarchy is clearly defined!

Asked in

a Amazon 85 G Google 42 f Meta 38 ⊞ Microsoft 31

The optimal solution uses a greedy two-stage approach with SQL CTEs. First, calculate average space per item type. Then, maximize prime items (priority constraint), followed by maximizing non-prime items in remaining space. This achieves O(n) time complexity with a single database query execution.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n)	O(n)	Try every possible combination of items within the space constraint
Optimized SQL Query (Single Pass)	O(n)	O(1)	Calculate optimal item distribution using CTEs and window functions in one query

Brute Force (Try All Combinations) — Algorithm Steps

Calculate total space needed for all prime items
Try all combinations of prime items that fit in 500,000 sq ft
For each valid prime combination, try all non-prime combinations for remaining space
Track the combination that maximizes total items while prioritizing prime items
Return the best combination found

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Space per Type

Find average space needed for prime and non-prime items

Prioritize Prime Items

Calculate maximum prime items that fit in 500,000 sq ft

Use Remaining Space

Fill leftover space with non-prime items

Return Results

Output item counts ordered by quantity

Code -

solution.c — C

// C SQL solution
#include <stdio.h>

const char* maximize_items_sql() {
    return ""
    "WITH item_metrics AS (\n"
    "    SELECT \n"
    "        item_type,\n"
    "        AVG(square_footage) as mean_footage\n"
    "    FROM Inventory\n"
    "    GROUP BY item_type\n"
    ")\n"
    "SELECT \n"
    "    item_type,\n"
    "    FLOOR(\n"
    "        CASE \n"
    "            WHEN item_type = 'prime_eligible' THEN \n"
    "                500000.0 / mean_footage\n"
    "            ELSE \n"
    "                (500000.0 - COALESCE(\n"
    "                    (SELECT FLOOR(500000.0 / mean_footage) * mean_footage \n"
    "                     FROM item_metrics \n"
    "                     WHERE item_type = 'prime_eligible'), 0)\n"
    "                ) / mean_footage\n"
    "        END\n"
    "    ) as item_count\n"
    "FROM item_metrics\n"
    "ORDER BY item_count DESC;\n";
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We try every possible subset of items, leading to exponential time complexity

⚠ Quadratic Growth

Space Complexity

O(n)

We need space to store the current combination and best result

⚡ Linearithmic Space

52.3K Views

High Frequency

~25 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler