廣度優先搜索：從盒子裏獲得的最大糖果數

一、題目介紹

給你 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;
    }
};