[LeetCode] 582. Kill Process

You have n processes forming a rooted tree structure. You are given two integer arrays pid and ppid, where pid[i] is the ID of the ith process and ppid[i] is the ID of the ith process's parent process.

Each process has only one parent process but may have multiple children processes. Only one process has ppid[i] = 0, which means this process has no parent process (the root of the tree).

When a process is killed, all of its children processes will also be killed.

Given an integer kill representing the ID of a process you want to kill, return a list of the IDs of the processes that will be killed. You may return the answer in any order.

Example 1:

Input: pid = [1,3,10,5], ppid = [3,0,5,3], kill = 5
Output: [5,10]
Explanation: The processes colored in red are the processes that should be killed.

Example 2:

Input: pid = [1], ppid = [0], kill = 1
Output: [1]

Constraints:

• n == pid.length
• n == ppid.length
• 1 <= n <= 5 * 104
• 1 <= pid[i] <= 5 * 104
• 0 <= ppid[i] <= 5 * 104
• Only one process has no parent.
• All the values of pid are unique.
• kill is guaranteed to be in pid.

杀死进程。

题意是给两个 list，一个叫做 pid，表示一堆进程的 id；一个叫做 ppid，表示一堆父进程的 id。同时给一个参数 kill 表示一个需要被结束的进程的 id。请问如果结束了 kill 进程，按照进程和父进程的关系，所有被杀死的进程都是哪些，用 list 输出。

这道题有 BFS 和 DFS 两种思路，两种做法的时间空间复杂度都是O(n)。这道题目给了 pid 和 ppid 两个数组，因为每个进程 process 只能有一个父进程，但是一个父进程有可能是有多个子进程的，所以这是一个类似多叉树的问题。这道题跟其他遍历类型的题不太一样的地方在于无论是 BFS 还是 DFS，首先都需要用一个数据结构创建/记录进程之间的父子关系。这里用 hashmap 相对比较合适。hashmap里是 <parentID, a list of childrenIDs>。

BFS

BFS的做法，既然一开始给了 kill 进程，所以在邻接关系创建好之后，就可以把 kill 进程放入 queue。从 queue 中弹出的时候，再把这个 kill 进程当做父进程，去找到他的所有子进程，放入 queue。

class Solution {
    public List<Integer> killProcess(List<Integer> pid, List<Integer> ppid, int kill) {
        HashMap<Integer, List<Integer>> map = new HashMap<>();
        // 对于每一个进程
        for (int i = 0; i < pid.size(); i++) {
            // 找到他的父进程
            int parent = ppid.get(i);
            // 创建邻接表
            // <parentId, list of childIDs>
            map.putIfAbsent(parent, new ArrayList<>());
            map.get(parent).add(pid.get(i));
        }

        List<Integer> res = new ArrayList<>();
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(kill);
        while (!queue.isEmpty()) {
            int cur = queue.poll();
            res.add(cur);
            queue.addAll(map.getOrDefault(cur, new ArrayList<>()));
        }
        return res;
    }
}

 

DFS

class Solution {
    public List<Integer> killProcess(List<Integer> pid, List<Integer> ppid, int kill) {
        // 建立邻接表
        HashMap<Integer, List<Integer>> map = new HashMap<>();
        for (int i = 0; i < pid.size(); i++) {
            int parent = ppid.get(i);
            map.putIfAbsent(parent, new ArrayList<>());
            map.get(parent).add(pid.get(i));
        }

        List<Integer> res = new ArrayList<>();
        res.add(kill);
        helper(map, res, kill);
        return res;
    }

    private void helper(HashMap<Integer, List<Integer>> map, List<Integer> res, int kill) {
        if (map.containsKey(kill)) {
            for (int p : map.get(kill)) {
                res.add(p);
                helper(map, res, p);
            }
        }
    }
}

 

LeetCode 题目总结