690. Employee Importance（dfs bfs） 1834. Single-Threaded CPU

我做的是广度遍历，根据第一个员工找子员工放入队列中，再根据子员工找出其下一个员工。。。。

 public int getImportance(List<Employee> employees, int id) {
        //存储员工id
        Queue<Integer> queue=new ArrayDeque<>();
        queue.add(id);
        //员工id 价值
        Map<Integer,Integer> map=new HashMap<>();
        //员工id 子员工
        Map<Integer,List<Integer>> map1=new HashMap<>();
        for (int i = 0; i < employees.size(); i++) {
            map.put(employees.get(i).id,employees.get(i).importance);
            map1.put(employees.get(i).id,employees.get(i).subordinates);
        }
        int res=0;
        while (!queue.isEmpty())
        {
            res+=map.get(queue.peek());
//            增加子员工
            for (int i = 0; i < map1.get(queue.peek()).size(); i++) {
                queue.add(map1.get(queue.peek()).get(i));
            }
            queue.poll();
        }



        return res;
    }

官方给出深度遍历

class Solution {
    Map<Integer, Employee> map = new HashMap<Integer, Employee>();

    public int getImportance(List<Employee> employees, int id) {
        for (Employee employee : employees) {
            map.put(employee.id, employee);
        }
        return dfs(id);
    }

    public int dfs(int id) {
        Employee employee = map.get(id);
        int total = employee.importance;
        List<Integer> subordinates = employee.subordinates;
        for (int subId : subordinates) {
            total += dfs(subId);
        }
        return total;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/employee-importance/solution/yuan-gong-de-zhong-yao-xing-by-leetcode-h6xre/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

单线程cpu 短作业优先算法

class Solution {
 class Task{
    int id;
    int enqueueTime;
    int processingTime;

    public Task(int id, int enqueueTime, int processingTime){
      this.id = id;
      this.enqueueTime = enqueueTime;
      this.processingTime = processingTime;
    }
  }
  public int[] getOrder(int[][] tasks) {
    int len = tasks.length;
    List<Task> taskList = new ArrayList<>();
    for(int i=0; i<len; i++){
      taskList.add(new Task(i, tasks[i][0], tasks[i][1]));
    }
    //按入队时间排序
    Collections.sort(taskList, (t1,t2) -> t1.enqueueTime - t2.enqueueTime);
    //利用最小堆获取下个要执行的任务
    PriorityQueue<Task> minHeap = new PriorityQueue<>((t1,t2) -> {
      if(t1.processingTime == t2.processingTime){
        //当执行时间相同时，根据id升序
        return t1.id - t2.id;
      }else{
        //当执行时间不同时，根据执行时间升序
        return t1.processingTime - t2.processingTime;
      }
    });
    long now = 0;//当前时间，使用long防止int溢出
    int i = 0;//taskList的坐标
    int[] ret = new int[len];
    int p = 0;//ret的坐标
    while(i<len){//taskList中还有任务没有放入堆时
      //将所有入队时间<=当前时间的任务放入堆中
      while(i<len && taskList.get(i).enqueueTime<=now){
        minHeap.offer(taskList.get(i));
        i++;
      }
      //当堆中没有任务，即当前cpu空闲
      if(minHeap.isEmpty()){
        //当前时间置为任务队列taskList中入队时间最小的时间
        now = (long)taskList.get(i).enqueueTime;
        while(i<len && taskList.get(i).enqueueTime<=now){
          minHeap.offer(taskList.get(i));
          i++;
        }
      }
      //此时保证堆中有任务待执行，取出执行即可
      Task task = minHeap.poll();
      ret[p++] = task.id;
      now += task.processingTime;
    }
    //当任务列表taskList中的全部任务已经入堆
    while(!minHeap.isEmpty()){
      //按顺序取出任务执行即可
      ret[p++] = minHeap.poll().id;
    }
    return ret;
  }
}