add 863

Author: fishercoder1534

Diff for: README.md

@@ -704,6 +704,7 @@ _If you like this project, please leave me a star._ ★
 | 870  | [Advantage Shuffle](https://leetcode.com/problems/advantage-shuffle/)                                                                                                                         | [Solution](../master/src/main/java/com/fishercoder/solutions/_870.java)                                                                  |                                                                               | Medium                           | Array, Greedy                                                        
 | 868  | [Binary Gap](https://leetcode.com/problems/binary-gap/)                                                                                                                                       | [Solution](../master/src/main/java/com/fishercoder/solutions/_868.java)                                                                  |                                                                               | Easy                             |
 | 867  | [Transpose Matrix](https://leetcode.com/problems/transpose-matrix/)                                                                                                                           | [Solution](../master/src/main/java/com/fishercoder/solutions/_867.java)                                                                  |                                                                               | Easy                             |
+| 863  | [All Nodes Distance K in Binary Tree](https://leetcode.com/problems/all-nodes-distance-k-in-binary-tree/)                                                                                                                           | [Solution](../master/src/main/java/com/fishercoder/solutions/_863.java)                                                                  |                                                                               | Medium                           | BFS
 | 861  | [Score After Flipping Matrix](https://leetcode.com/problems/score-after-flipping-matrix/)                                                                                                     | [Solution](../master/src/main/java/com/fishercoder/solutions/_861.java)                                                                  |                                                                               | Medium                           | Greedy                                                               
 | 860  | [Lemonade Change](https://leetcode.com/problems/lemonade-change/)                                                                                                                             | [Solution](../master/src/main/java/com/fishercoder/solutions/_860.java)                                                                  |                                                                               | Easy                             |
 | 859  | [Buddy Strings](https://leetcode.com/problems/buddy-strings/)                                                                                                                                 | [Solution](../master/src/main/java/com/fishercoder/solutions/_859.java)                                                                  |                                                                               | Easy                             |

Diff for: src/main/java/com/fishercoder/solutions/_863.java

@@ -0,0 +1,60 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+
+import java.util.*;
+
+public class _863 {
+    public static class Solution1 {
+        /**
+         * Since it's asking for distance k, a.k.a shortest distance, BFS should be the way to go.
+         * For this particular problem: we'll do BFS twice:
+         * 1st time: we build a child to parent mapping, in binary tree, there's only parent to children mapping, so we'll need to establish this child to parent link;
+         * 2nd time: we push the target node into the queue, traverse all its neighbors (children and parent),
+         * push them into the queue and decrement k by one, until k becomes zero, remaining elements in the queue are the answer.
+         */
+        public List<Integer> distanceK(TreeNode root, TreeNode target, int k) {
+            Map<Integer, TreeNode> childToParentMap = new HashMap<>();
+            Queue<TreeNode> queue = new LinkedList<>();
+            queue.offer(root);
+            while (!queue.isEmpty()) {
+                int size = queue.size();
+                for (int i = 0; i < size; i++) {
+                    TreeNode curr = queue.poll();
+                    if (curr.left != null) {
+                        childToParentMap.put(curr.left.val, curr);
+                        queue.offer(curr.left);
+                    }
+                    if (curr.right != null) {
+                        childToParentMap.put(curr.right.val, curr);
+                        queue.offer(curr.right);
+                    }
+                }
+            }
+            queue.offer(target);
+            Set<Integer> visited = new HashSet<>();
+            while (k > 0 && !queue.isEmpty()) {
+                int size = queue.size();
+                for (int i = 0; i < size; i++) {
+                    TreeNode curr = queue.poll();
+                    visited.add(curr.val);
+                    if (curr.left != null && !visited.contains(curr.left.val)) {
+                        queue.offer(curr.left);
+                    }
+                    if (curr.right != null && !visited.contains(curr.right.val)) {
+                        queue.offer(curr.right);
+                    }
+                    if (childToParentMap.containsKey(curr.val) && !visited.contains(childToParentMap.get(curr.val).val)) {
+                        queue.offer(childToParentMap.get(curr.val));
+                    }
+                }
+                k--;
+            }
+            List<Integer> list = new ArrayList<>();
+            while (!queue.isEmpty()) {
+                list.add(queue.poll().val);
+            }
+            return list;
+        }
+    }
+}