You are given a data structure of employee information, which includes the employee's unique id, his importance value and his directsubordinates' id.node
For example, employee 1 is the leader of employee 2, and employee 2 is the leader of employee 3. They have importance value 15, 10 and 5, respectively. Then employee 1 has a data structure like [1, 15, [2]], and employee 2 has [2, 10, [3]], and employee 3 has [3, 5, []]. Note that although employee 3 is also a subordinate of employee 1, the relationship is not direct.python
Now given the employee information of a company, and an employee id, you need to return the total importance value of this employee and all his subordinates.app
Example 1:
函数
Input: [[1, 5, [2, 3]], [2, 3, []], [3, 3, []]], 1 Output: 11 Explanation: Employee 1 has importance value 5, and he has two direct subordinates: employee 2 and employee 3. They both have importance value 3. So the total importance value of employee 1 is 5 + 3 + 3 = 11.
Note:
this
个人答案:spa
# Employee info class Employee(object): def __init__(self, id, importance, subordinates): # It's the unique id of each node. # unique id of this employee self.id = id # the importance value of this employee self.importance = importance # the id of direct subordinates self.subordinates = subordinates class Solution(object): def getImportance(self, employees, id): """ :type employees: Employee :type id: int :rtype: int """ id_list = [] importance_list = [] sub_list = [] for i in range(0, len(employees)): id_list.append(employees[i].id) importance_list.append(employees[i].importance) sub_list.append(employees[i].subordinates) id_importance_zipped = zip(id_list, importance_list) id_sub_zipped = zip(id_list, sub_list) id_importance_dict = dict(id_importance_zipped) # 全局字典,就是hashtable id_sub_dict = dict(id_sub_zipped) # 全局字典 def dfs(id): total_importance = id_importance_dict[id] if len(id_sub_dict[id]) == 0: # 若是没下属 return total_importance else:#若是有下属 for sub_id in id_sub_dict[id]: total_importance = total_importance + dfs(sub_id) return total_importance return dfs(id) sol=Solution() emp1=Employee(1,5,[2,3]) emp2=Employee(2,3,[4]) emp3=Employee(3,4,[]) emp4=Employee(4,1,[]) employees=[emp1,emp2,emp3,emp4] id=1 total=sol.getImportance(employees,id)
total Out[1]: 13
1.我选了一道tag为HashTable的这道题,从网上查了一下python经过字典实现hashtable,茅塞顿开。调试
想分别把id-imporatnce这个键值对code
和id-subordinates这个键值对 orm
存成两个字典 对象
2. 我意识到上述两个字典必须是全局变量,不然的话,好比本题中我举的例子:
id=1的员工有子员工id=2和id=3 ,而id=2的员工有子员工id=4, 若是上述两个字典不是全局变量,则id=4没法查找到键为4的键值对,会报Keyerror的错误
3.题意确实是深度优先搜索
综上所述写出了正确答案,可是超级慢399ms只战胜了6.98%的用户。
因而看了别人更快的代码(172ms,最快):
class Solution(object): def getImportance(self, employees, id): """ :type employees: Employee :type id: int :rtype: int """ return employees[id - 1].importance + sum( [self.getImportance(employees, subordinate_id) for subordinate_id in employees[id - 1].subordinates])
class Employee(object): def __init__(self, id, importance, subordinates): # It's the unique id of each node. # unique id of this employee self.id = id # the importance value of this employee self.importance = importance # the id of direct subordinates self.subordinates = subordinates class Solution(object): def getImportance(self, employees, id): """ :type employees: Employee :type id: int :rtype: int """ # Time: O(n) # Space: O(n) emps = {employee.id: employee for employee in employees} def dfs(id): subordinates_importance = sum([dfs(sub_id) for sub_id in emps[id].subordinates]) return subordinates_importance + emps[id].importance return dfs(id) sol=Solution() #employees=[[1, 5, [2, 3]], [2, 3, []], [3, 3, []]] emp1=Employee(1,5,[2,3]) emp2=Employee(2,3,[4]) emp3=Employee(3,4,[]) emp4=Employee(4,1,[]) employees=[emp1,emp2,emp3,emp4] id=1 total=sol.getImportance(employees,id)
经验总结:
1. 我一开始把结果sum=sol.getImportance(employees,id)
这样的话我再调试的时候,写sum([6,7,8])
就会报TypeError: 'int' object is not callable
发现是个人变量名占用了关键字的名字(也不能占用函数的名字)
深入教训,不能再犯
2.
sum([ ]) Out[4]: 0 sum([id for id in []]) Out[5]: 0