add 582

fishercoder1534 · fishercoder1534 · commit 22cbe0d8b988 · 2017-05-18T08:07:01.000-07:00
diff --git a/README.md b/README.md
@@ -20,6 +20,7 @@ Your ideas/fixes/algorithms are more than welcome!
 
 |  #  |      Title     |   Solutions   | Time          | Space         | Difficulty  | Tag          | Notes
 |-----|----------------|---------------|---------------|---------------|-------------|--------------|-----
+|582|[Kill Process](https://leetcode.com/problems/kill-process/)|[Solution](../master/src/main/java/com/stevesun/solutions/_582.java) | O(n) |O(h) | Medium | Stack
 |581|[Shortest Unsorted Continuous Subarray](https://leetcode.com/problems/shortest-unsorted-continuous-subarray/)|[Solution](../master/src/main/java/com/stevesun/solutions/_581.java) | O(n) |O(1) | Easy | Array, Sort
 |575|[Distribute Candies](https://leetcode.com/problems/distribute-candies/)|[Solution](../master/src/main/java/com/stevesun/solutions/_575.java) | O(nlogn) |O(1) | Easy | Array
 |572|[Subtree of Another Tree](https://leetcode.com/problems/subtree-of-another-tree/)|[Solution](../master/src/main/java/com/stevesun/solutions/_572.java) | O(m*n) |O(1) | Easy | Tree
diff --git a/src/main/java/com/stevesun/solutions/_582.java b/src/main/java/com/stevesun/solutions/_582.java
@@ -0,0 +1,56 @@
+package com.stevesun.solutions;
+
+import java.util.*;
+
+/**
+ * 582. Kill Process
+ *
+ * Given n processes, each process has a unique PID (process id) and its PPID (parent process id).
+
+ Each process only has one parent process, but may have one or more children processes. This is just like a tree structure. Only one process has PPID that is 0, which means this process has no parent process. All the PIDs will be distinct positive integers.
+
+ We use two list of integers to represent a list of processes, where the first list contains PID for each process and the second list contains the corresponding PPID.
+
+ Now given the two lists, and a PID representing a process you want to kill, return a list of PIDs of processes that will be killed in the end. You should assume that when a process is killed, all its children processes will be killed. No order is required for the final answer.
+
+ Example 1:
+ Input:
+ pid =  [1, 3, 10, 5]
+ ppid = [3, 0, 5, 3]
+ kill = 5
+ Output: [5,10]
+
+ Explanation:
+     3
+   /   \
+  1     5
+       /
+      10
+
+ Kill 5 will also kill 10.
+
+ Note:
+ The given kill id is guaranteed to be one of the given PIDs.
+ n >= 1.
+ */
+public class _582 {
+
+    public List<Integer> killProcess(List<Integer> pid, List<Integer> ppid, int kill) {
+        Map<Integer, List<Integer>> map = new HashMap<>();
+        for (int i = 0; i < pid.size(); i++) {
+            map.putIfAbsent(ppid.get(i), new LinkedList<>());
+            map.get(ppid.get(i)).add(pid.get(i));
+        }
+        List<Integer> result = new LinkedList<>();
+        Deque<Integer> stack = new ArrayDeque<>();
+        stack.offer(kill);
+        while (!stack.isEmpty()) {
+            int curr = stack.poll();
+            result.add(curr);
+            List<Integer> list = map.get(curr);
+            if (list != null) stack.addAll(list);
+        }
+        return result;
+    }
+
+}
diff --git a/src/test/java/com/stevesun/_582Test.java b/src/test/java/com/stevesun/_582Test.java
@@ -0,0 +1,46 @@
+package com.stevesun;
+
+import com.stevesun.solutions._48;
+import com.stevesun.solutions._582;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Created by stevesun on 5/18/17.
+ */
+public class _582Test {
+    private static _582 test;
+    private static List<Integer> pid;
+    private static List<Integer> ppid;
+    private static List<Integer> expected;
+    private static Integer kill;
+
+    @BeforeClass
+    public static void setup(){
+        test = new _582();
+    }
+
+    @Test
+    public void test1(){
+        pid = Arrays.asList(1,3,10,5);
+        ppid = Arrays.asList(3,0,5,3);
+        kill = 5;
+        expected = Arrays.asList(5,10);
+        assertEquals(expected, test.killProcess(pid, ppid, kill));
+    }
+
+    @Test
+    public void test2(){
+        pid = Arrays.asList(1,3,10,5);
+        ppid = Arrays.asList(3,0,5,3);
+        kill = 3;
+        expected = Arrays.asList(3,1,5,10);
+        assertEquals(expected, test.killProcess(pid, ppid, kill));
+    }
+}
