广度优先搜索：从盒子里获得的最大糖果数

一、题目介绍

给你 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

二、解题思路

可以将之抽象成N叉树的遍历问题，但注意，因为找到钥匙和盒子的顺序不一定，可能先找到钥匙再找到对应盒子，也可能相反，因此，如果用深度优先遍历，那每次都得从根节点开始做一次全局遍历，但如果用广度优先遍历，可将之前所有取到的盒子或者钥匙先暂存，这样就只需要遍历整棵树一次。
解题主要采用了广度优先的非递归写法，过程中使用队列作为辅助手段，主体代码如下：

class Solution {
public:
    int maxCandies(vector<int>& status, vector<int>& candies, vector<vector<int>>& keys,
        vector<vector<int>>& containedBoxes, vector<int>& initialBoxes)
    {
        if (initialBoxes.size() == 0) return 0;

        int maxCandies = 0;
        //找到盒子和对应钥匙的顺序有先有后，需全部存下
        vector<int>vecKeys;//存放所有钥匙
        vector<int>vecCLosedBoxes;//存放所有盒子
        queue<int> queOpenBoxes;//存放所有能打开的盒子

        for (int i = 0; i < initialBoxes.size(); i++)
        {
            if (status[i] == 1)
                queOpenBoxes.push(initialBoxes[i]);
            else
                vecCLosedBoxes.push_back(initialBoxes[i]);
        }

        while (queOpenBoxes.size() != 0)
        {
            int box = queOpenBoxes.front();
            queOpenBoxes.pop();
           
            //将该盒子内糖果取出
            maxCandies += candies[box];

            //存下该盒子内所有钥匙
            for (auto key : keys[box])
            {
                vecKeys.push_back(key);
            }
            
            //存下所有盒子
            for (auto containBox : containedBoxes[box])
            {
                if (status[containBox] == 1)
                    queOpenBoxes.push(containBox);
                else
                    vecCLosedBoxes.push_back(containBox);
            }

            //打开已经找到的盒子放入队列
            if (vecKeys.size() == 0 || vecCLosedBoxes.size() == 0)
                continue;


            for (auto iterKey=vecKeys.begin();iterKey!=vecKeys.end();iterKey++)
            {
                for (auto iterBox = vecCLosedBoxes.begin();iterBox!=vecCLosedBoxes.end();iterBox++)
                {
                    if (*iterKey == *iterBox)
                    {

                        queOpenBoxes.push(*iterBox);
                        vecKeys.erase(iterKey);
                        vecCLosedBoxes.erase(iterBox);

                        if (vecCLosedBoxes.size()==0)
                            break;
                        continue;
                    }                        
                }
                if (vecKeys.size()==0)
                    break;
            }     
        }
        return maxCandies;
    }
};