《五月集训》（第十七天）——广度优先搜索

前言

        欢迎大家积极在评论区留言发表自己的看法，知无不言，言无不尽，养成每天刷题的习惯，也可以自己发布优质的解题报告，供社区一同鉴赏，吸引一波自己的核心粉丝。
        今天是五月集训第十七天：广度优先搜索🔥🔥🔥🔥🔥

一、练习题目

        LCP 44. 开幕式焰火
        102. 二叉树的层序遍历
        1609. 奇偶树
        1263. 推箱子

二、算法思路

• 1、LCP 44. 开幕式焰火:😄利用前面学的队列存放节点，哈希表记录结点的值之前是否出现过。(套路很深)
• 2、102. 二叉树的层序遍历：😄和上一题一样用队列存放节点，同时需要记录深度。（做着做着还是套路）
• 3、1609. 奇偶树：😄这题直接套第二题，用它的函数返回层序遍历的二维数组，然后再对二维数组进行奇偶判断。（✈️感觉这种会的cv工程师当的好爽）。
• 4、1263. 推箱子：🔥直接上困难题了，打回原型，我是fw，还没消化放一放…

三、源码剖析

// LCP 44. 开幕式焰火
class Solution {
public:
    int numColor(TreeNode* root) {
        int hash[1001], cnt = 0;
        queue<TreeNode*> q;
        memset(hash, 0, sizeof(hash));
        q.push(root); //(1)
        while(!q.empty()) {
            TreeNode *now = q.front();
            q.pop();
            if(now) {
                if(!hash[now->val]) { //(2)
                    hash[now->val] = 1;
                    cnt++;
                }
                q.push(now->left);
                q.push(now->right);
            }
        }
        return cnt;
    }
};

• 1、根节点先入队列，然后广度优先搜索扩展结点;
• 2、利用哈希表同统计计数。

// 102. 二叉树的层序遍历
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        if(root == nullptr) {
            return {};
        }
        vector<vector<int>> ans;
        unordered_map<TreeNode*, int> depth;
        int predep = -1;
        queue<TreeNode*> q;
        q.push(root); 
        depth[root] = 0; //(1)
        while(!q.empty()) {
            TreeNode* now = q.front();
            q.pop();
            if(predep != depth[now]) { //(2)
                vector<int> tmp;
                tmp.emplace_back(now->val);
                ans.emplace_back(tmp);
                predep = depth[now];
            } else {
                ans.back().emplace_back(now->val); //(3)
            }
            if(now->left) {
                depth[now->left] = depth[now] + 1;
                q.push(now->left);
            }
            if(now->right) {
                depth[now->right] = depth[now] + 1;
                q.push(now->right);
            } //(4)
        }
        return ans;
    }
};

• 1、记录深度用；
• 2、这是深度不同的情况，用一个一维数组去暂存，再放到二维数组中，表明是新的一层；
• 3、不是新的一层，直接在数组的最后那里进行一个插入；
• 4、后面就是广搜模板，今天这三题都是这么过来的。

// 1609. 奇偶树
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) { //(1)
        if(root == nullptr) {
            return {};
        }
        vector<vector<int>> ans;
        unordered_map<TreeNode*, int> depth;
        int predep = -1;
        queue<TreeNode*> q;
        q.push(root);
        depth[root] = 0;
        while(!q.empty()) {
            TreeNode* now = q.front();
            q.pop();
            if(predep != depth[now]) {
                vector<int> tmp;
                tmp.emplace_back(now->val);
                ans.emplace_back(tmp);
                predep = depth[now];
            } else {
                ans.back().emplace_back(now->val);
            }
            if(now->left) {
                depth[now->left] = depth[now] + 1;
                q.push(now->left);
            }
            if(now->right) {
                depth[now->right] = depth[now] + 1;
                q.push(now->right);
            }
        }
        return ans;
    }

    bool isEvenOddTree(TreeNode* root) {
        vector<vector<int>> ret = levelOrder(root);
        for(int i = 0; i < ret.size(); ++i) {
            if(i&1) {
                for(int j = 0; j < ret[i].size(); ++j) {
                    if(ret[i][j]&1) {
                        return false;
                    }
                    if(j && ret[i][j] >= ret[i][j - 1]) {
                        return false;
                    }
                }
            } else {
                for(int j = 0; j < ret[i].size(); ++j) {
                    if((ret[i][j]&1) == 0) {
                        return false;
                    }
                    if(j && ret[i][j] <= ret[i][j - 1]) {
                        return false;
                    }
                }
            }
        } //(2)
        return true;
    }
};

• 1、套用第二题的函数进行一个层序遍历，返回二维数组；
• 2、根据题目意思对这个二维数组进行奇偶的判断，一点点去写即可。

🐦🐦🐦

// 1263. 推箱子
咕咕咕咕咕

• 1、