2020.9.8 LeetCode

1.员工的重要性

给定一个保存员工信息的数据结构，它包含了员工唯一的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, 5, [2, 3] ] , [2, 3, [ ] ] , [3, 3, [ ] ] ] , 1
输出: 11
解释:员工1自身的重要度是5，他有两个直系下属2和3，而且2和3的重要度均为3。因此员工1的总重要度是 5 + 3 + 3 = 11。

分析：

• 方法一
  使用深度优先搜索（DFS），先在公司的员工信息中找出题目给的id对应的员工信息，并赋值给另一个元素。接下来再遍历这个员工所对应的下属，将他们所对应的重要度全部加起来。

• 方法二
  使用迭代法，创建一个队列，存放题目要求的员工id，进行循环。将入队的id出队，并循环所给的员工信息，当两者id相等时，加上其重要度，再将这员工对应的下属id入队，进行下一轮循环，直到队列中没有元素为止。

class Employee {
    public int id;
    public int importance;
    public List<Integer> subordinates;
}

//方法一
class Solution{
    public int getImportance(List<Employee> employees, int id){
        Employee root = null;
        for(Employee e : employees){
            if(e.id == id){
                root = e;
                break;
            }
        }
        int ans = root.importance;
        for(int sub : root.subordinates){
            ans += getImportance(employees, sub);
        }
        return ans;
    }
}

//方法二
class Solution{
    public int getImportance(List<Employee> employees, int id){
        if(employees.size() == 0) return 0;
        Queue<Integer> q = new LinkedList<>();
        q.offer(id);
        int res = 0;
        while(q.size() != 0){
            int temp = q.poll();
            for(Employee e : employees){
                if(e.id == temp){
                    res += e.importance;
                    for(int num : e.subordinates){
                        q.offer(num);
                    }
                }
            } 
        }
        return res;
    }
}

2. 翻转数位

分析：

• 从左至右一位位检测num，与1相与。若不为0，则当前位数加1。若为0，则将当前位数与前一段只隔一个0的左位数相加，并判断之前的结果和现在的结果，取较大者。·

class Solution{
    public int reverseBits(int num){
        int res = 0;
        int leftSum = 0;
        int nowSum = 0;
        for(int i = 31; i >= 0; i--){
            if((num & (1 << i)) != 0){
                nowSum++;
            }else{
                res = Math.max(res, leftSum + nowSum);
                leftSum = nowSum + 1; //前面连续的1的个数再加上这个0，即等于把这个0变为1后这串连续的1的总长度
                nowSum = 0;
            }
        }
        res = Math.max(res, leftSum + nowSum);
        return res;
    }
}