题目描述

给你 n 个盒子，每个盒子的格式为 [status, candies, keys, containedBoxes]，其中：

• 状态字 status[i]：整数，如果 box[i] 是开的，那么是 1，否则是 0。
• 糖果数 candies[i]: 整数，表示 box[i] 中糖果的数目。
• 钥匙 keys[i]：数组，表示你打开 box[i] 后，可以得到一些盒子的钥匙，每个元素分别为该钥匙对应盒子的下标。
• 内含的盒子 containedBoxes[i]：整数，表示放在 box[i] 里的盒子所对应的下标。

给你一个 initialBoxes 数组，表示你现在得到的盒子，你可以获得里面的糖果，也可以用盒子里的钥匙打开新的盒子，还可以继续探索从这个盒子里找到的其他盒子。

请你按照上述规则，返回可以获得糖果的 最大数目。

样例

输入：
status = [1,0,1,0],
candies = [7,5,4,100],
keys = [[],[],[1],[]],
containedBoxes = [[1,2],[3],[],[]],
initialBoxes = [0]
输出：16
解释：
一开始你有盒子 0。你将获得它里面的 7 个糖果和盒子 1 和 2。
盒子 1 目前状态是关闭的，而且你还没有对应它的钥匙。
所以你将会打开盒子 2，并得到里面的 4 个糖果和盒子 1 的钥匙。
在盒子 1 中，你会获得 5 个糖果和盒子 3，但是你没法获得盒子 3 的钥匙所以盒子 3 会保持关闭状态。
你总共可以获得的糖果数目 = 7 + 4 + 5 = 16 个。

输入：
status = [1,0,0,0,0,0],
candies = [1,1,1,1,1,1],
keys = [[1,2,3,4,5],[],[],[],[],[]],
containedBoxes = [[1,2,3,4,5],[],[],[],[],[]],
initialBoxes = [0]
输出：6
解释：
你一开始拥有盒子 0 。打开它你可以找到盒子 1,2,3,4,5 和它们对应的钥匙。
打开这些盒子，你将获得所有盒子的糖果，所以总糖果数为 6 个。

输入：status = [1,1,1],
candies = [100,1,100],
keys = [[],[0,2],[]],
containedBoxes = [[],[],[]],
initialBoxes = [1]
输出：1

输入：status = [1],
candies = [100],
keys = [[]],
containedBoxes = [[]],
initialBoxes = []
输出：0

输入：
status = [1,1,1],
candies = [2,3,2],
keys = [[],[],[]],
containedBoxes = [[],[],[]],
initialBoxes = [2,1,0]
输出：7

限制

• 1 <= status.length <= 1000
• status.length == candies.length == keys.length == containedBoxes.length == n
• status[i] 要么是 0 要么是 1。
• 1 <= candies[i] <= 1000
• 0 <= keys[i].length <= status.length
• 0 <= keys[i][j] < status.length
• 0 <= containedBoxes[i].length <= status.length
• 0 <= containedBoxes[i][j] < status.length
• containedBoxes[i] 中的值都是互不相同的。
• 每个盒子最多被一个盒子包含。
• 0 <= initialBoxes.length <= status.length
• 0 <= initialBoxes[i] < status.length

算法1

(暴力模拟) $O(n^2)$

1. 定义一个集合，存储尚未打开的盒子。
2. 每次操作，遍历集合中的每一个盒子，看是否可以打开，如果可以打开并从集合中移除。加入这个盒子中存放的其他盒子，用这个盒子中的钥匙来更新其他盒子的状态。
3. 如果某次操作发现无法打开新的盒子，则结束。

时间复杂度

• 每次操作，最坏情况需要遍历 $O(n)$ 的盒子。每次操作至少都会消除一个未打开的盒子，所以最多有 $O(n)$ 次操作。
• 故总时间复杂度为 $O(n^2)$。

空间复杂度

• 需要额外 $O(n)$ 的空间记录未打开的盒子。

C++ 代码

class Solution {
public:
    int maxCandies(
        vector<int>& status,
        vector<int>& candies,
        vector<vector<int>>& keys,
        vector<vector<int>>& containedBoxes,
        vector<int>& initialBoxes) {

        int res = 0;
        unordered_set<int> boxes(initialBoxes.begin(), initialBoxes.end());

        while (1) {
            unordered_set<int> new_boxes;
            unordered_set<int> opened_boxes;
            for (int x : boxes)
                if (status[x]) {
                    opened_boxes.insert(x);
                    res += candies[x];
                    for (int k : keys[x])
                        status[k] = true;

                    for (int b : containedBoxes[x])
                        new_boxes.insert(b);
                }

            if (opened_boxes.empty())
                break;

            for (int b : opened_boxes)
                boxes.erase(b);

            for (int b : new_boxes)
                boxes.insert(b);
        }

        return res;
    }
};

算法2

(队列优化) $O(n)$

1. 将已经可以打开的箱子放进队列逐一遍历，没有钥匙的箱子放进一个集合（pending_boxes）中等待。status 数组始终用来维护这个箱子可以立刻打开。
2. 每次从队列中取出一个箱子打开，累加了糖果后，首先遍历其中的钥匙，如果 pending_boxes 中有这个箱子，则将其入队；否则，把钥匙对应的 status 位置变为 true。
3. 然后遍历这个盒子中的箱子，如果某个箱子可以立刻打开，则放入队列；否则放入 pending_boxes 集合中。

时间复杂度

• 每个箱子仅会进入队列和 pending_boxes 集合一次，在这种意义上看，时间复杂度为 $O(n)$。
• 但有可能每个箱子里都有 $O(n)$ 个钥匙，这样时间复杂度就变为了 $O(n^2)$。

空间复杂度

• 需要额外 $O(n)$ 的空间用于队列和 pending_boxes。

C++ 代码

class Solution {
public:
    int maxCandies(
        vector<int>& status,
        vector<int>& candies,
        vector<vector<int>>& keys,
        vector<vector<int>>& containedBoxes,
        vector<int>& initialBoxes) {

        int res = 0;
        unordered_set<int> pending_boxes;
        queue<int> q;

        for (int b : initialBoxes) {
            if (status[b])
                q.push(b);
            else
                pending_boxes.insert(b);
        }

        while (!q.empty()) {
            int x = q.front();
            q.pop();
            res += candies[x];

            for (int k : keys[x]) {
                if (pending_boxes.find(k) != pending_boxes.end()) {
                    q.push(k);
                    pending_boxes.erase(k);
                } else {
                    status[k] = true;
                }
            }

            for (int b : containedBoxes[x]) {
                if (status[b])
                    q.push(b);
                else
                    pending_boxes.insert(b);
            }
        }

        return res;
    }
};