Maximum Candies You Can Get from Boxes - Practice Coding Problems

Maximum Candies You Can Get from Boxes - Problem

Imagine you're exploring a mysterious treasure chamber filled with magical boxes containing candies! 🍭

You have n boxes labeled from 0 to n-1. Each box has unique properties:

Status: Some boxes are initially open (status = 1), others are locked (status = 0)
Candies: Each box contains a certain number of delicious candies
Keys: Opening a box may reveal keys to unlock other boxes
Hidden Boxes: Some boxes contain other boxes inside them!

You start with an array initialBoxes - the boxes you can access initially. Your mission is to collect the maximum number of candies possible by strategically opening boxes, using keys, and discovering hidden boxes.

Rules:

You can only take candies from open boxes
Keys found in opened boxes can unlock other boxes you possess
Boxes found inside opened boxes are added to your collection
You can only open boxes that you physically have AND have the right key/status for

Input & Output

example_1.py — Basic Case

$ Input: status = [1,0,1,0], candies = [7,5,4,9], keys = [[],[],[1],[]], containedBoxes = [[1,2],[3],[],[]], initialBoxes = [0]

› Output: 16

💡 Note: Start with box 0 (open, 7 candies). Box 0 contains boxes 1,2. Open box 2 (open, 4 candies), get key to box 1. Open box 1 with key (5 candies). Box 1 contains box 3, but we can't open it (closed, no key). Total: 7+4+5=16

example_2.py — All Boxes Accessible

$ Input: status = [1,0,0,0], candies = [1,1,1,1], keys = [[1,2,3],[],[],[]], containedBoxes = [[],[],[],[]], initialBoxes = [0]

› Output: 4

💡 Note: Box 0 is open with 1 candy and contains keys to boxes 1,2,3. We can open all boxes and collect all 4 candies.

example_3.py — No Additional Boxes

$ Input: status = [1], candies = [100], keys = [[]], containedBoxes = [[]], initialBoxes = [0]

› Output: 100

💡 Note: Only one box, already open. Simply collect its 100 candies.

Constraints

1 ≤ n ≤ 1000
0 ≤ status[i] ≤ 1
0 ≤ candies[i] ≤ 1000
0 ≤ keys[i].length ≤ n
0 ≤ keys[i][j] < n
0 ≤ containedBoxes[i].length ≤ n
0 ≤ containedBoxes[i][j] < n
1 ≤ initialBoxes.length ≤ n
0 ≤ initialBoxes[i] < n
All values in initialBoxes are distinct
All values in keys[i] are distinct
All values in containedBoxes[i] are distinct

Visualization

Tap to expand

Understanding the Visualization

Inventory Check

Check what boxes you have and what keys you possess

Opening Spree

Open all boxes you can (either already open or you have the key)

Collect Resources

Gather candies, add new keys to keychain, add new boxes to inventory

Repeat or Finish

If new boxes can be opened, repeat; otherwise you're done

Key Takeaway

🎯 Key Insight: This is a graph traversal problem where boxes are nodes and keys/containment create edges. BFS with state tracking ensures optimal O(n) solution.

Asked in

a Amazon 25 G Google 18 ⊞ Microsoft 12 f Meta 8

The optimal solution uses BFS with state tracking to systematically explore all reachable boxes. We maintain sets of available boxes, keys, and opened boxes, processing all openable boxes in each round until no more progress can be made. This achieves O(n) time complexity by ensuring each box is processed exactly once.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n * n!)	O(n)	Recursively try all possible sequences of opening boxes
BFS with State Tracking (Optimal)	O(n)	O(n)	Use BFS to systematically explore reachable boxes while tracking keys and available boxes

Brute Force (Try All Combinations) — Algorithm Steps

Start with initial boxes and empty key set
For each state, try opening each accessible box
Recursively explore all possible next states
Track maximum candies across all paths
Return the global maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with initial boxes and no keys

Branch on Choices

For each openable box, create a new branch

Recursive Exploration

Explore each branch to find maximum candies

Backtrack & Compare

Compare results from all branches

Code -

solution.c — C

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

int dfs(bool* available, bool* keySet, bool* opened, int n, int* status, int* candies, 
        int** keys, int* keySizes, int** containedBoxes, int* containedSizes) {
    int maxCandies = 0;
    
    for (int box = 0; box < n; box++) {
        if (!available[box] || opened[box]) continue;
        
        bool canOpen = status[box] == 1 || keySet[box];
        if (!canOpen) continue;
        
        bool* newAvailable = malloc(n * sizeof(bool));
        bool* newKeys = malloc(n * sizeof(bool));
        bool* newOpened = malloc(n * sizeof(bool));
        
        memcpy(newAvailable, available, n * sizeof(bool));
        memcpy(newKeys, keySet, n * sizeof(bool));
        memcpy(newOpened, opened, n * sizeof(bool));
        
        newOpened[box] = true;
        int currentCandies = candies[box];
        
        for (int i = 0; i < keySizes[box]; i++) {
            newKeys[keys[box][i]] = true;
        }
        
        for (int i = 0; i < containedSizes[box]; i++) {
            newAvailable[containedBoxes[box][i]] = true;
        }
        
        int futureCandies = dfs(newAvailable, newKeys, newOpened, n, status, candies, keys, keySizes, containedBoxes, containedSizes);
        if (currentCandies + futureCandies > maxCandies) {
            maxCandies = currentCandies + futureCandies;
        }
        
        free(newAvailable);
        free(newKeys);
        free(newOpened);
    }
    
    return maxCandies;
}

int maxCandies(int* status, int statusSize, int* candies, int candiesSize, int** keys, int keysSize, int* keysColSize,
               int** containedBoxes, int containedBoxesSize, int* containedBoxesColSize, int* initialBoxes, int initialBoxesSize) {
    bool* available = calloc(statusSize, sizeof(bool));
    bool* keySet = calloc(statusSize, sizeof(bool));
    bool* opened = calloc(statusSize, sizeof(bool));
    
    for (int i = 0; i < initialBoxesSize; i++) {
        available[initialBoxes[i]] = true;
    }
    
    int result = dfs(available, keySet, opened, statusSize, status, candies, keys, keysColSize, containedBoxes, containedBoxesColSize);
    
    free(available);
    free(keySet);
    free(opened);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n!)

In worst case, we explore exponential number of states with factorial branching

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and storage for current state

⚡ Linearithmic Space

31.2K Views

Medium Frequency

~25 min Avg. Time

890 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