DFS / BFS员工的重要性

/*
// Definition for Employee.
class Employee {
public:
int id;
int importance;
vector subordinates;
};
*/
给定一个保存员工信息的数据结构，它包含了员工唯一的id，重要度 和 直系下属的id。

比如，员工1是员工2的领导，员工2是员工3的领导。他们相应的重要度为15, 10, 5。那么员工1的数据结构是[1, 15, [2]]，员工2的数据结构是[2, 10, [3]]，员工3的数据结构是[3, 5, []]。注意虽然员工3也是员工1的一个下属，但是由于并不是直系下属，因此没有体现在员工1的数据结构中。

现在输入一个公司的所有员工信息，以及单个员工id，返回这个员工和他所有下属的重要度之和。

示例 1:

输入: [[1, 5, [2, 3]], [2, 3, []], [3, 3, []]], 1
输出: 11
解释:
员工1自身的重要度是5，他有两个直系下属2和3，而且2和3的重要度均为3。因此员工1的总重要度是 5 + 3 + 3 = 11。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/employee-importance

注意的是 ： 经理的重要性等于自己的加上底下所以员工的重要性。
员工不重复计算

采用深搜思想 ：

每个员工都可能有下属： 因此可以借助递归处理

 这里的递归采用的是深度优先搜索的思想。
深度优先搜索类似于二叉树的递归遍历

class Solution {
public:
    int dfs(unordered_map<int,Employee*>& mp , int id)
    {
            if(mp[id] == nullptr || mp.size() == 0)
                return 0;
              int ret = mp[id]->importance;
              for(auto n : mp[id]->subordinates)
            {
                ret += dfs(mp, n);
            }
        return ret;
    }
    int getImportance(vector<Employee*> employees, int id) {
        if(employees.size() == 0) return 0; 
        //保存所有员工id  和 下属表                    
        unordered_map<int, Employee*> mp;

        //制作下属表。类似于建造二叉树
        for(auto it : employees)
        {   
            if(it == nullptr ) continue;
            //保存所有员工   三项信息 
            mp[it->id] = it;
        }
        return dfs(mp, id);
    }
};

/*
// Definition for Employee.
class Employee {
public:
int id;
int importance;
vector subordinates;
};
*/

class Solution {
public:
    int dfs(unordered_map<int,Employee*>& mp , int id)
    {
            if(mp[id] == nullptr || mp.size() == 0)
                return 0;

            int ret = mp[id]->importance;
            for(auto n : mp[id]->subordinates)
            {
                ret += dfs(mp, n);
            }
        return ret;
    }
    int getImportance(vector<Employee*> employees, int id) {
        if(employees.size() == 0) return 0; 
        //保存所有员工id  和 下属表                    
        unordered_map<int, Employee*> mp;

        //制作下属表。类似于建造二叉树
        for(auto it : employees)
        {   
            if(it == nullptr ) continue;
            //保存所有员工   三项信息 
            mp[it->id] = it;
        }
        return dfs(mp, id);
    }
};

广度优先搜索：

思想 ： 类似于二叉树的层序遍历。 当前员工是，将下属员工的信息保存在队列中

class Solution
{
    public:
     int getImportance(vector<Employee*> employees, int id) {
    unordered_map<int , Employee*> mp;
    for(auto e : employees)
    {
        if(e == nullptr)  continue;
        mp[e->id] = e;
    }

    queue<int>q;
    q.push(mp[id]->id);    

    int ret=0;
    while(!q.empty())
    {
        ret += mp[q.front()]->importance;
        //存放当前员工工号 //注意只能存工号， 存权重不存在子下属，所以不行
        for(auto e : mp[q.front()]->subordinates)
        {
            q.push(e);
        }
        q.pop();
    }
    return ret;
    }
};