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

前言

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

一、练习题目

        2059. 转化数字的最小运算数
        690. 员工的重要性
        672. 灯泡开关 Ⅱ

二、算法思路

• 1、2059. 转化数字的最小运算数：广搜。🔥🔥
• 2、690. 员工的重要性：广搜的思路，哈希表加深度优先搜索。🔥🔥
• 3、672. 灯泡开关 Ⅱ：🔥🔥🔥🔥

三、源码剖析

// 2059. 转化数字的最小运算数
#define maxn 1010
class Solution {
public:
    int minimumOperations(vector<int>& nums, int start, int goal) {
        queue<int> q;
        int step[maxn];
        memset(step, -1, sizeof(step));
        q.push(start);
        step[start] = 0;
        int x, nextx;
        while(!q.empty()) {
            x = q.front();
            q.pop();
            for(int i = 0; i < nums.size(); ++i) {
                nextx = x + nums[i];
                if(nextx == goal) {
                    return step[x] + 1;
                }
                if(nextx <= 1000 && nextx >= 0) {
                    if(step[nextx] == -1) {
                        step[nextx] = step[x] + 1;
                        q.push(nextx);
                    }
                }
                nextx = x - nums[i];
                if(nextx == goal) {
                    return step[x] + 1;
                }
                if(nextx <= 1000 && nextx >= 0) {
                    if(step[nextx] == -1) {
                        step[nextx] = step[x] + 1;
                        q.push(nextx);
                    }
                }

                nextx = (x ^ nums[i]);
                if(nextx == goal) {
                    return step[x] + 1;
                }
                if(nextx <= 1000 && nextx >= 0) {
                    if(step[nextx] == -1) {
                        step[nextx] = step[x] + 1;
                        q.push(nextx);
                    }
                } //(1)
            }
        }
        return -1;
    }
};

• 1、每次遍历数组，执行三种状态，放入队列中，如果超过$[0,1000]$的就不进行扩展。

// 690. 员工的重要性
/*
// Definition for Employee.
class Employee {
public:
    int id;
    int importance;
    vector<int> subordinates;
};
*/

class Solution {
    unordered_map<int, Employee* > id2Emp;  //(1)
public:
    int dfs(int id) {
        Employee* emp = id2Emp[id];
        if(emp == nullptr) {
            return 0;
        }

        int sum = emp->importance;
        for(int i = 0; i < emp->subordinates.size(); ++i) {
            sum += dfs(emp->subordinates[i]);
        }
        return sum;
    }
    int getImportance(vector<Employee*> employees, int id) {
        for(int i  = 0; i < employees.size(); ++i) {
            id2Emp[employees[i]->id] = employees[i];
        }
        return dfs(id); //(2)  
    }
};

• 1、用哈希表来记录id和员工的映射；
• 2、用一个深度优先搜索去统计该id到所有下属的权重的总和。

// 

• 1、