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

Raphael Liu Lv10
  2023-09-13 00:47:26 2023-09-13 00:47:26 Created   2023-09-13 16:06:32 2023-09-13 16:06:32 Updated    

给你 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 <= 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
  • keys[i] 中的值都是互不相同的。
  • 0 <= containedBoxes[i].length <= status.length
  • 0 <= containedBoxes[i][j] < status.length
  • containedBoxes[i] 中的值都是互不相同的。
  • 每个盒子最多被一个盒子包含。
  • 0 <= initialBoxes.length <= status.length
  • 0 <= initialBoxes[i] < status.length

方法一：广度优先搜索

我们可以使用广度优先搜索 + 队列的方法解决这个问题。

对于第 i 个盒子，我们只有拥有这个盒子（在初始时就拥有或从某个盒子中开出）并且能打开它（在初始时就是打开的状态或得到它的钥匙），才能获得其中的糖果。我们用数组 has_box 表示每个盒子是否被拥有，数组 can_open 表示每个盒子是否能被打开。在搜索前，我们只拥有数组 initialBoxes 中的那些盒子，并且能打开数组 status 值为 0 对应的那些盒子。如果一个盒子在搜索前满足这两条要求，就将其放入队列中。

在进行广度优先搜索时，每一轮我们取出队首的盒子 k 将其打开，得到其中的糖果、盒子 containedBoxes[k] 以及钥匙 keys[k]。我们将糖果加入答案，并依次枚举每个盒子以及每把钥匙。在枚举盒子时，如果该盒子可以被打开，就将其加入队尾；同理，在枚举钥匙时，如果其对应的盒子已经被拥有，就将该盒子加入队尾。当队列为空时，搜索结束，我们就得到了得到糖果的最大数目。

[sol1-C++]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
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> can_open(n), has_box(n), used(n);
        for (int i = 0; i < n; ++i) {
            can_open[i] = (status[i] == 1);
        }

        queue<int> q;
        int ans = 0;
        for (int box: initialBoxes) {
            has_box[box] = true;
            if (can_open[box]) {
                q.push(box);
                used[box] = true;
                ans += candies[box];
            }
        }
        
        while (!q.empty()) {
            int big_box = q.front();
            q.pop();
            for (int key: keys[big_box]) {
                can_open[key] = true;
                if (!used[key] && has_box[key]) {
                    q.push(key);
                    used[key] = true;
                    ans += candies[key];
                }
            }
            for (int box: containedBoxes[big_box]) {
                has_box[box] = true;
                if (!used[box] && can_open[box]) {
                    q.push(box);
                    used[box] = true;
                    ans += candies[box];
                }
            }
        }
        
        return ans;
    }
};
[sol1-Python3]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class Solution:
    def maxCandies(self, status: List[int], candies: List[int], keys: List[List[int]], containedBoxes: List[List[int]], initialBoxes: List[int]) -> int:
        n = len(status)
        can_open = [status[i] == 1 for i in range(n)]
        has_box, used = [False] * n, [False] * n
        
        q = collections.deque()
        ans = 0
        for box in initialBoxes:
            has_box[box] = True
            if can_open[box]:
                q.append(box)
                used[box] = True
                ans += candies[box]
        
        while len(q) > 0:
            big_box = q.popleft()
            for key in keys[big_box]:
                can_open[key] = True
                if not used[key] and has_box[key]:
                    q.append(key)
                    used[key] = True
                    ans += candies[key]
            for box in containedBoxes[big_box]:
                has_box[box] = True
                if not used[box] and can_open[box]:
                    q.append(box)
                    used[box] = True
                    ans += candies[box]
        
        return ans

复杂度分析

  • 时间复杂度：O(N)。题目保证了每一把钥匙在 keys 中不会出现超过一次，并且每一个盒子在 containedBoxes 中也不会出现超过一次，因此在广度优先搜索中最多会得到 N 把钥匙和 N 个盒子，总时间复杂度为 O(N)。

  • 空间复杂度：O(N)。

 Comments
On this page
1298-你能从盒子里获得的最大糖果数