[Function add]

1. Add leetcode solutions.

Author: Seanforfun

leetcode/210. Course Schedule II.md

@@ -195,4 +195,46 @@ class Solution {
 			return remain.isEmpty() ? order: new int[0];
 		}
 	}
+	```
+
+### Amazon Session
+* Method 1: Topological sort
+	```Java
+	class Solution {
+		public int[] findOrder(int numCourses, int[][] prerequisites) {
+			Map<Integer, List<Integer>> map = new HashMap<>();
+			int[] indegree = new int[numCourses];
+			for(int[] req : prerequisites){
+				indegree[req[0]]++;
+				List<Integer> list = map.getOrDefault(req[1], new ArrayList<>());
+				list.add(req[0]);
+				map.put(req[1], list);
+			}
+			Queue<Integer> q = new LinkedList<>();
+			for(int i = 0; i < numCourses; i++){
+				if(indegree[i] == 0){
+					q.offer(i);
+				}
+			}
+			List<Integer> result = new ArrayList<>();
+			while(!q.isEmpty()){
+				int cur = q.poll();
+				result.add(cur);
+				if(!map.containsKey(cur)) continue;
+				List<Integer> neighbours = map.get(cur);
+				for(Integer n : neighbours){
+					if(--indegree[n] == 0){
+						q.offer(n);
+					}
+				}
+			}
+			if(result.size() != numCourses) return new int[0];
+			int[] res = new int[numCourses];
+			int index = 0;
+			while(index < numCourses){
+				res[index] = result.get(index++);
+			}
+			return res;
+		}
+	}
 	```

leetcode/772. Basic Calculator III.md

@@ -67,3 +67,50 @@ Some examples:
       }
   }
   ```
+
+### Amazon session
+* Method 1: recursion + stack
+	```Java
+	class Solution {
+		private char[] arr;
+		private int i;
+		public int calculate(String s) {
+			this.arr = s.toCharArray();
+			return parse();
+		}
+		private int parse(){
+			char oper = '+';
+			int sum = 0;
+			Stack<Integer> stack = new Stack<>();
+			while(i < arr.length){
+				char c = arr[i];
+				if(c == '('){
+					i++;
+					addToStack(stack, oper, parse());
+				}else if(Character.isDigit(c)){
+					int cur = c - '0';
+					i++;
+					while(i < arr.length && Character.isDigit(arr[i])){
+						cur = cur * 10 + arr[i++] - '0';
+					}
+					addToStack(stack, oper, cur);
+				}else if(c == ')'){
+					while(!stack.isEmpty()) sum += stack.pop();
+					i++;
+					return sum;
+				}else if(c == '+' || c == '-' || c == '*' || c == '/'){
+					oper = c;
+					i++;
+				}else if(c == ' ') i++;
+			}
+			while(!stack.isEmpty()) sum += stack.pop();
+			return sum;
+		}
+		private void addToStack(Stack<Integer> stack, char c, int num){
+			if(c == '+') stack.push(num);
+			else if(c == '-') stack.push(-num);
+			else if(c == '*') stack.push(stack.pop() * num);
+			else stack.push(stack.pop() / num);
+		}
+	}
+	```

leetcode/993. Cousins in Binary Tree.md

@@ -75,3 +75,45 @@ Note:
         }
     }
     ```
+
+### Amazon Session
+* Method 1: bfs
+	```Java
+	/**
+	 * Definition for a binary tree node.
+	 * public class TreeNode {
+	 *     int val;
+	 *     TreeNode left;
+	 *     TreeNode right;
+	 *     TreeNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+		public boolean isCousins(TreeNode root, int x, int y) {
+			Queue<TreeNode> q = new LinkedList<>();
+			if(root.val == x || root.val == y) return false;
+			q.offer(root);
+			while(!q.isEmpty()){
+				Set<Integer> value = new HashSet<>();
+				int size = q.size();
+				for(int i = 0; i < size; i++){
+					TreeNode node = q.poll();
+					if(node.left != null && node.right != null){
+						if((node.left.val == x && node.right.val == y)
+						  || (node.left.val == y && node.right.val == x)) return false;
+					}
+					if(node.left != null){
+						q.offer(node.left);
+						value.add(node.left.val);
+					} 
+					if(node.right != null){
+						q.offer(node.right);
+						value.add(node.right.val);
+					} 
+				}
+				if(value.contains(x) && value.contains(y)) return true;
+			}
+			return false;
+		}
+	}
+	```