Leetcode.1298 你能从盒子里获得的最大糖果数

题目链接

Leetcode.1298 你能从盒子里获得的最大糖果数 rating : 1825

题目描述

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

• 状态字 $status[i]$：整数，如果 $box[i]$ 是开的，那么是 $1$ ，否则是 $0$ 。
• 糖果数 $candies[i]$: 整数，表示 $box[i]$ 中糖果的数目。
• 钥匙 $keys[i]$：数组，表示你打开 $box[i]$ 后，可以得到一些盒子的钥匙，每个元素分别为该钥匙对应盒子的下标。
• 内含的盒子 $containedBoxes[i]$：整数，表示放在 $box[i]$ 里的盒子所对应的下标。
• 给你一个 $initialBoxes$ 数组，表示你现在得到的盒子，你可以获得里面的糖果，也可以用盒子里的钥匙打开新的盒子，还可以继续探索从这个盒子里找到的其他盒子。

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

示例 1：

输入：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 个。

示例 2：

输入：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 个。

示例 3：

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

示例 4：

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

示例 5：

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

提示：

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

解法：bfs

我们用一个哈希表 $have\_key$ 记录手里拥有的钥匙；

我们用一个哈希表 $have\_box$ 记录手里拥有的箱子；

我们用 $vis$ 记录访问过的盒子（能够打开的）；

初始时，我们将 $initialBoxes$ 里的 处于 打开状态（也就是 $status[i]=1$） 的盒子 $i$ 入队。

进行bfs。

取出队首盒子 $t$ ，累加能够获得的糖果 $candies[t]$ ，此时打开盒子 $t$ ，获得的新的盒子是 $boxes$ ，获得的新钥匙是 $key$。

遍历新钥匙 $key$，如果我们手中有对应的没打开的盒子，那我们就将其入队，$vis$记录下来。

遍历新盒子 $boxes$，如果我们手中有对应的钥匙 或是 这个盒子本身就处于打开的状态，那我们就将其入队，$vis$记录下来。

时间复杂度： $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 n = status.size();
        vector<bool> vis(n);
        
        //记录持有的钥匙 和 盒子
        unordered_set<int> have_key , have_box;
        queue<int> q;

        for(auto box:initialBoxes){
            //记录盒子
            have_box.insert(box);
            
            //能够打开的盒子才将其入队
            if(status[box]){
                q.push(box);
                vis[box] = true;
            }
        }

        int ans = 0;

        while(!q.empty()){
            auto t = q.front();
            q.pop();
            
            //累加糖果
            ans += candies[t];

            auto key = keys[t];
            auto boxes = containedBoxes[t];
            
            //遍历新钥匙 ， 如果有对应的盒子就将其入队，记录下来
            for(auto k:key){
                have_key.insert(k);
                if(!vis[k] && have_box.count(k)){
                    q.push(k);
                    vis[k] = true;
                }
            }

            //遍历新盒子 ， 如果有对应的钥匙 或是 这个盒子本身就处于打开状态 就将其入队，记录下来
            for(auto box:boxes){
                have_box.insert(box);
                if(!vis[box] && (have_key.count(box) || status[box])){
                    q.push(box);
                    vis[box] = true;
                }
            }
        }

        return ans;
    }
};