[Function add]

1. Add leetcode solutions with tag amazon.

Author: Seanforfun

leetcode/314. Binary Tree Vertical Order Traversal.md

@@ -163,4 +163,50 @@ Output:
             return result;
         }
     }
-   ```
+   ```
+
+### Amazon session
+* Method 1: dfs + TreeMap
+	```Java
+	/**
+	 * Definition for a binary tree node.
+	 * public class TreeNode {
+	 *     int val;
+	 *     TreeNode left;
+	 *     TreeNode right;
+	 *     TreeNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+		// key: colNum, value: (key: rowNum, value: node values)
+		private TreeMap<Integer, TreeMap<Integer, List<Integer>>> map;
+		public List<List<Integer>> verticalOrder(TreeNode root) {
+			this.map = new TreeMap<>();
+			List<List<Integer>> result = new ArrayList<>();
+			if(root == null) return result;
+			// use recursion to add nodes to tree map.
+			dfs(0, 0, root);
+			// add to result;
+			for(TreeMap<Integer, List<Integer>> out: map.values()){
+				List<Integer> list = new ArrayList<>();
+				for(List<Integer> value: out.values()){
+					list.addAll(value);
+				}
+				result.add(list);
+			}
+			return result;
+		}
+		private void dfs(int x, int y, TreeNode node){
+			if(node == null) return;
+			else{
+				TreeMap<Integer, List<Integer>> cur = map.getOrDefault(y, new TreeMap<>());
+				List<Integer> list = cur.getOrDefault(x, new ArrayList<>());
+				list.add(node.val);
+				cur.put(x, list);
+				map.put(y, cur);
+				dfs(x + 1, y - 1, node.left);
+				dfs(x + 1, y + 1, node.right);
+			}
+		}
+	}
+	```

leetcode/545. Boundary of Binary Tree.md

@@ -104,4 +104,50 @@ So order them in anti-clockwise without duplicate nodes we have [1,2,4,7,8,9,10,
 			if(node.right != null) dfs(node.right, list);
 		}
 	}
+	```
+
+### Amazon Session
+* Method 1: DFS
+	```Java
+	/**
+	 * Definition for a binary tree node.
+	 * public class TreeNode {
+	 *     int val;
+	 *     TreeNode left;
+	 *     TreeNode right;
+	 *     TreeNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+		List<Integer> result;
+		public List<Integer> boundaryOfBinaryTree(TreeNode root) {
+			this.result = new ArrayList<>();
+			if(root == null) return this.result;
+			result.add(root.val);
+			dfsLeft(root.left);
+			dfsLeaves(root.left);
+			dfsLeaves(root.right);
+			dfsRight(root.right);
+			return result;
+		}
+		private void dfsLeft(TreeNode node){
+			if(node == null || (node.left == null && node.right == null)) return;
+			result.add(node.val);
+			dfsLeft(node.left == null ? node.right: node.left);
+		}
+		private void dfsRight(TreeNode node){
+			if(node == null || (node.left == null && node.right == null)) return;
+			dfsRight(node.right == null ? node.left: node.right);
+			result.add(node.val);
+		}
+		private void dfsLeaves(TreeNode node){
+			if(node == null) return;
+			else if(node.left == null && node.right == null){
+				this.result.add(node.val);
+				return;
+			}
+			dfsLeaves(node.left);
+			dfsLeaves(node.right);
+		}
+	}
 	```

leetcode/863. All Nodes Distance K in Binary Tree.md

@@ -88,4 +88,71 @@ Note:
             graph.put(node, neighbours);
         }
     }
-    ```
+    ```
+
+### Amazon session
+* Method 1: dfs + bfs
+	```Java
+	/**
+	 * Definition for a binary tree node.
+	 * public class TreeNode {
+	 *     int val;
+	 *     TreeNode left;
+	 *     TreeNode right;
+	 *     TreeNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+		private Map<TreeNode, List<TreeNode>> g;
+		public List<Integer> distanceK(TreeNode root, TreeNode target, int K) {
+			g = new HashMap<>();
+			List<Integer> result = new ArrayList<>();
+			dfs(root);  // create a graph
+			Queue<TreeNode> q = new LinkedList<>();
+			q.offer(target);
+			int level = 0;
+			Set<TreeNode> visited = new HashSet<>();
+			visited.add(target);
+			while(!q.isEmpty() && level < K){
+				int size = q.size();
+				for(int sz = 0; sz < size; sz++){
+					TreeNode cur = q.poll();
+					if(g.containsKey(cur)){
+						List<TreeNode> neighbours = g.get(cur);
+						for(TreeNode n: neighbours){
+							if(!visited.contains(n)){
+								visited.add(n);
+								q.offer(n);
+							}
+						}
+					}
+				}
+				level++;
+			}
+			if(level == K){
+				for(TreeNode n: q){
+					result.add(n.val);
+				}
+			}
+			return result;
+		}
+		private void dfs(TreeNode node){
+			List<TreeNode> neighbours = g.getOrDefault(node, new ArrayList<>());
+			if(node.left != null){
+				neighbours.add(node.left);
+				List<TreeNode> lefts = g.getOrDefault(node.left, new ArrayList<>());
+				lefts.add(node);
+				g.put(node.left, lefts);
+				dfs(node.left);
+			}
+			if(node.right != null){
+				neighbours.add(node.right);
+				List<TreeNode> rights = g.getOrDefault(node.right, new ArrayList<>());
+				rights.add(node);
+				g.put(node.right, rights);
+				dfs(node.right);
+			}
+			g.put(node, neighbours);
+		}
+	}
+	```