(深搜 + 广搜 + 哈希) LeetCode 690. 员工的重要性

原题链接

一. 题目描述

你有一个保存员工信息的数据结构，它包含了员工唯一的 id ，重要度和直系下属的 id 。

给定一个员工数组 employees，其中：

employees[i].id 是第 i 个员工的 ID。
employees[i].importance 是第 i 个员工的重要度。
employees[i].subordinates 是第 i 名员工的直接下属的 ID 列表。
给定一个整数 id 表示一个员工的 ID，返回这个员工和他所有下属的重要度的 总和。

示例 1：

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

示例 2：

输入：employees = [[1,2,[5]],[5,-3,[]]], id = 5
输出：-3
解释：员工 5 的重要度为 -3 并且没有直接下属。
因此，员工 5 的总重要度为 -3。
 

提示：

1 <= employees.length <= 2000
1 <= employees[i].id <= 2000
所有的 employees[i].id 互不相同。
-100 <= employees[i].importance <= 100
一名员工最多有一名直接领导，并可能有多名下属。
employees[i].subordinates 中的 ID 都有效。

二. 解题思路

本题的题意也比较简单，给你一个结构体的员工信息数组，每个数组中含有三个元素， 员工的 id，员工的重要性，员工手底下的小喽啰。然后给你一个员工的 id ，需要你求出这个员工的重要性总和，注意这里的重要性不仅包括该员工自己的，还包括他手底下员员工的。

聪明的同学一眼就可以看出来这是一个树形结构，每一个id 都映射了重要性和手下员工这两个属性，所有我们在做之前得将他们以哈希的方式映射起来。

可以有两种映射方式：（1）以id 为下标将重要性和手下员工分别存储在两个vector 数组中，如下：

        vector<int> important(2005);
        vector<vector<int>> sub(2005, vector<int>(2005));
        for(int i = 0; i < employees.size(); i++){
            important[employees[i]->id] = employees[i]->importance;
            sub[employees[i]->id] = employees[i]->subordinates;
        }

（2）将所有员工信息存储到以id 为键的map 中，如下：

        unordered_map<int, Employee*> mp;
        for(auto & it : employees){
            mp[it->id] = it;
        }

 然后我们开始搜：

1. 广搜： 定义一个q 的队列，将id 存储，然后开始循环遍历，每一次将所属id 的员工存储到q 中，再将该id 的重要性添加到结果中即可。

2. 深搜：直接遍历员工的下属数组，然后将下属的重要性添加即可。

话不多说！！！上代码！！

三. 代码

1. 深搜：

class Solution {
public:
    unordered_map<int, Employee*> mp;
    int total = 0;
    int dfs(int id){
        int total = mp[id]->importance;        // 当前id 的员工的重要性
        for(int i = 0; i < mp[id]->subordinates.size(); i++){
            total += dfs(mp[id]->subordinates[i]);        //递归添加当前员工的下属的重要性
        }
        return total;
    }
    int getImportance(vector<Employee*> employees, int id) {
        for(auto & it : employees){        // 哈希映射关系
            mp[it->id] = it;
        }
        return dfs(id);;
    }
};

2. 广搜：

class Solution {
public:
    int getImportance(vector<Employee*> employees, int id) {
        int res = 0;
        vector<int> important(2005);    // 映射重要性
        vector<vector<int>> sub(2005, vector<int>(2005));    // 映射下属员工
        for(int i = 0; i < employees.size(); i++){
            important[employees[i]->id] = employees[i]->importance;
            sub[employees[i]->id] = employees[i]->subordinates;
        }
        queue<int> q;        // 存储id
        if(important[id] == 0) return res;     // 总重要性
        q.push(id);
        while(!q.empty()){
            int size = q.size();
            while(size--){
                int id = q.front(); q.pop();
                res += important[id];        // 添加该员工的重要性
                for(int i = 0; i < sub[id].size(); i++){        // 将该员工的下属添加到队列中
                    q.push(sub[id][i]);
                }
            }
        }
        return res;
    }
};

四. 总结

本题属于搜索的基本题目，感兴趣的同学可以练习一下。

深搜时间复杂度：O(N)； 深搜空间复杂度：O(N)。

广搜时间复杂度：O(N + E)； 广搜空间复杂度：O(N)。

喜欢的话给个关注吧！！