[Function add]

1. Add leetcode solutions with amazon tag.

Author: Seanforfun

leetcode/333. Largest BST Subtree.md

@@ -0,0 +1,61 @@
+## 333. Largest BST Subtree
+
+### Question
+Given a binary tree, find the largest subtree which is a Binary Search Tree (BST), where largest means subtree with largest number of nodes in it.
+
+Note:
+A subtree must include all of its descendants.
+
+```
+Example:
+
+Input: [10,5,15,1,8,null,7]
+
+   10 
+   / \ 
+  5  15 
+ / \   \ 
+1   8   7
+
+Output: 3
+Explanation: The Largest BST Subtree in this case is the highlighted one.
+             The return value is the subtree's size, which is 3.
+```
+
+Follow up:
+Can you figure out ways to solve it with O(n) time complexity?
+
+### Solution:
+* Method 1: recursion, bottom to top
+	1. There are 4 necessary parameters to return.
+	2. 0: isBST, 1: min, 2: max, 3: number of nodes
+	```Java
+	/**
+	 * Definition for a binary tree node.
+	 * public class TreeNode {
+	 *     int val;
+	 *     TreeNode left;
+	 *     TreeNode right;
+	 *     TreeNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+		public int largestBSTSubtree(TreeNode root) {
+			if(root == null) return 0;
+			int[] res = helper(root);
+			return res[3];
+		}
+		private int[] helper(TreeNode node){// 0: isBST, 1: min, 2: max, 3: number of nodes
+			int[] left = new int[]{1, node.val, node.val, 0};
+			int[] right = new int[]{1, node.val, node.val, 0};
+			if(node.left != null) left = helper(node.left);
+			if(node.right != null) right = helper(node.right);
+			boolean isBST = left[0] == 1 
+				&& right[0] == 1 
+				&& (node.left != null ? node.val > left[2]: true) 
+				&& (node.right != null ? node.val < right[1]: true);
+			int number = isBST ? 1 + left[3] + right[3] : Math.max(left[3], right[3]);
+			return new int[]{isBST ? 1: 0, left[1], right[2], number};
+		}
+	}
+	```

leetcode/508. Most Frequent Subtree Sum.md

@@ -73,3 +73,48 @@ Note: You may assume the sum of values in any subtree is in the range of 32-bit
       }
   }
   ```
+
+### Amazon Session
+* Method 1: recursion, bottom to top
+	```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<Integer, Integer> map;
+		public int[] findFrequentTreeSum(TreeNode root) {
+			if(root == null) return new int[0];
+			this.map = new HashMap<>();
+			dfs(root);
+			int max = 0, count = 0;
+			for(int freq : map.values()){
+				if(freq > max){
+					count = 1;
+					max = freq;
+				}else if(freq == max) count++;
+			}
+			int[] res = new int[count];
+			int index = 0;
+			for(Map.Entry<Integer, Integer> entry: map.entrySet()){
+				if(entry.getValue() == max){
+					res[index++] = entry.getKey();
+				}
+			}
+			return res;
+		}
+		private int dfs(TreeNode node){
+			int left = 0,  right = 0;
+			if(node.left != null) left = dfs(node.left);
+			if(node.right != null) right = dfs(node.right);
+			int sum = left + right + node.val;
+			map.put(sum, map.getOrDefault(sum, 0) + 1);
+			return sum;
+		}
+	}
+	```

leetcode/55. Jump Game.md

@@ -61,4 +61,19 @@ class Solution {
         return true;
     }
 }
-```
+```
+
+### Amazon session
+* Method 1: Greedy
+	```Java
+	class Solution {
+		public boolean canJump(int[] nums) {
+			int max = 0;
+			for(int i = 0; i < nums.length; i++){
+				if(max < i) return false;
+				max = Math.max(max, i + nums[i]);
+			}
+			return true;
+		}
+	}
+	```