Maximum Candies You Can Get from Boxes

Maximum Candies You Can Get from Boxes - Problem

You have n boxes labeled from 0 to n - 1. You are given four arrays:

status[i] is 1 if the i^th box is open and 0 if closed
candies[i] is the number of candies in the i^th box
keys[i] is a list of labels of boxes you can open after opening the i^th box
containedBoxes[i] is a list of boxes you find inside the i^th box

You are given an integer array initialBoxes that contains the labels of boxes you initially have.

Rules:

You can take all candies from any open box
You can use keys found in opened boxes to open new boxes
You can use boxes found inside opened boxes

Return the maximum number of candies you can get following the rules above.

Input & Output

Example 1 — Basic Case

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

› Output: 16

💡 Note: Start with box 0 (open) → collect 7 candies. Box 2 is also open → collect 4 candies. Box 0 has no keys, box 2 gives key to box 1 → open box 1 and collect 5 candies. Total: 7+4+5=16

Example 2 — Keys Required

$ 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 → collect 1 candy and get keys [1,2]. Open boxes 1,2 → collect 2 more candies and get key [3]. Open box 3 → collect 1 candy. Total: 1+1+1+1=4

Example 3 — Contained Boxes

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

› Output: 7

💡 Note: Start with box 0 → collect 2 candies and find boxes [1,2]. Boxes 1,2 are both open → collect 3+2=5 candies. Total: 2+3+2=7

Constraints

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

Visualization

Tap to expand

Asked in

G Google 45 M Microsoft 32 A Amazon 28 F Facebook 22

The key insight is that the order of opening boxes doesn't matter for the total candy count - we just need to find all boxes that can eventually be reached and opened. The optimal approach uses BFS-style iteration to systematically open all accessible boxes until no more progress can be made. Time: O(n), Space: O(n)

Common Approaches

✓ Breadth-First Search (BFS)

⏱️ Time: O(n) Space: O(n)

Process boxes in BFS manner - start with initial boxes, open what we can, collect candies/keys/boxes, then process newly accessible boxes. Continue until no more boxes can be opened.

Recursive Exploration with All Permutations

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

Generate all possible sequences of opening available boxes and recursively explore each path to find the maximum candies. This approach tries every permutation of box-opening orders.

Breadth-First Search (BFS) — Algorithm Steps

Initialize queue with initial boxes and track available keys
While queue not empty, process each openable box
Collect candies, keys, and contained boxes
Add newly accessible boxes to queue

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with initial boxes and empty key collection

Iterate

Each round, open all currently openable boxes

Expand

Collect candies, keys, and new boxes from opened boxes

Repeat

Continue until no more boxes can be opened

Code -

solution.c — C

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

#define MAX_BOXES 1000

int solution(int status[], int candies[], int keys[][MAX_BOXES], int keySizes[], int containedBoxes[][MAX_BOXES], int boxSizes[], int initialBoxes[], int initialSize, int n) {
    int totalCandies = 0;
    int availableBoxes[MAX_BOXES] = {0};
    int hasKeys[MAX_BOXES] = {0};
    int opened[MAX_BOXES] = {0};
    
    // Initialize available boxes
    for (int i = 0; i < initialSize; i++) {
        availableBoxes[initialBoxes[i]] = 1;
    }
    
    int changed = 1;
    while (changed) {
        changed = 0;
        
        // Find boxes we can open in this iteration
        int openableBoxes[MAX_BOXES];
        int openableCount = 0;
        
        // Check available boxes
        for (int i = 0; i < n; i++) {
            if (availableBoxes[i] && !opened[i] && (status[i] == 1 || hasKeys[i])) {
                openableBoxes[openableCount++] = i;
                availableBoxes[i] = 0;  // Remove from available
                changed = 1;
            }
        }
        
        // Check if any other boxes can be opened with current keys
        for (int i = 0; i < n; i++) {
            if (!opened[i] && !availableBoxes[i] && hasKeys[i]) {
                openableBoxes[openableCount++] = i;
                changed = 1;
            }
        }
        
        // Open all openable boxes
        for (int i = 0; i < openableCount; i++) {
            int box = openableBoxes[i];
            opened[box] = 1;
            totalCandies += candies[box];
            
            // Add keys
            for (int j = 0; j < keySizes[box]; j++) {
                hasKeys[keys[box][j]] = 1;
            }
            
            // Add contained boxes
            for (int j = 0; j < boxSizes[box]; j++) {
                availableBoxes[containedBoxes[box][j]] = 1;
            }
        }
    }
    
    return totalCandies;
}

int main() {
    // Simplified example input parsing
    int n = 4;
    int status[] = {1, 0, 1, 0};
    int candies[] = {7, 5, 4, 9};
    int keys[MAX_BOXES][MAX_BOXES] = {{}, {}, {1}, {}};
    int keySizes[] = {0, 0, 1, 0};
    int containedBoxes[MAX_BOXES][MAX_BOXES] = {{}, {}, {}, {}};
    int boxSizes[] = {0, 0, 0, 0};
    int initialBoxes[] = {0};
    int initialSize = 1;
    
    printf("%d\n", solution(status, candies, keys, keySizes, containedBoxes, boxSizes, initialBoxes, initialSize, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each box is processed at most once, and each key/contained box is examined once

✓ Linear Growth

Space Complexity

O(n)

Queue, sets for tracking keys and available boxes can hold up to n elements

⚡ Linearithmic Space

34.6K Views

Medium Frequency

~25 min Avg. Time

892 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

Breadth-First Search (BFS) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler