[Function add]

1. Add leetcode solutions with tag Amazon.

Author: Seanforfun

leetcode/341. Flatten Nested List Iterator.md

@@ -75,4 +75,61 @@ public class NestedIterator implements Iterator<Integer> {
  * NestedIterator i = new NestedIterator(nestedList);
  * while (i.hasNext()) v[f()] = i.next();
  */
-```
+```
+
+### Amazon Session
+* Method 1: recursion
+	```Java
+	/**
+	 * // This is the interface that allows for creating nested lists.
+	 * // You should not implement it, or speculate about its implementation
+	 * public interface NestedInteger {
+	 *
+	 *     // @return true if this NestedInteger holds a single integer, rather than a nested list.
+	 *     public boolean isInteger();
+	 *
+	 *     // @return the single integer that this NestedInteger holds, if it holds a single integer
+	 *     // Return null if this NestedInteger holds a nested list
+	 *     public Integer getInteger();
+	 *
+	 *     // @return the nested list that this NestedInteger holds, if it holds a nested list
+	 *     // Return null if this NestedInteger holds a single integer
+	 *     public List<NestedInteger> getList();
+	 * }
+	 */
+	public class NestedIterator implements Iterator<Integer> {
+		private List<Integer> list;
+		private int index;
+		public NestedIterator(List<NestedInteger> nestedList) {
+			if(nestedList == null || nestedList.size() == 0) return;
+			this.list = new ArrayList<>();
+			getValues(nestedList);        
+		}
+		private void getValues(List<NestedInteger> list){
+			for(NestedInteger obj : list){
+				if(obj.isInteger()) this.list.add(obj.getInteger());
+				else{
+					List<NestedInteger> next = obj.getList();
+					getValues(next);
+				}
+			}
+		}
+
+		@Override
+		public Integer next() {
+			return this.list.get(index++);
+		}
+
+		@Override
+		public boolean hasNext() {
+			if(this.list == null)  return false;
+			return index < this.list.size();
+		}
+	}
+
+	/**
+	 * Your NestedIterator object will be instantiated and called as such:
+	 * NestedIterator i = new NestedIterator(nestedList);
+	 * while (i.hasNext()) v[f()] = i.next();
+	 */
+	```

leetcode/662. Maximum Width of Binary Tree.md

@@ -107,3 +107,46 @@ Note: Answer will in the range of 32-bit signed integer.
 		}
 	}
 	```
+
+### Amazon Session
+* Method 1:
+	```Java
+	/**
+	 * Definition for a binary tree node.
+	 * public class TreeNode {
+	 *     int val;
+	 *     TreeNode left;
+	 *     TreeNode right;
+	 *     TreeNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+		private static final class Node{
+			TreeNode node;
+			int index;
+			public Node(TreeNode node, int index){
+				this.node = node;
+				this.index = index;
+			}
+		}
+		public int widthOfBinaryTree(TreeNode root) {
+			if(root == null) return 0;
+			Queue<Node> q = new LinkedList<>();
+			q.offer(new Node(root, 1));
+			int res = 1;
+			while(!q.isEmpty()){
+				int size = q.size();
+				int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
+				for(int sz = 0; sz < size; sz++){
+					Node n = q.poll();
+					min = Math.min(min, n.index);
+					max = Math.max(max, n.index);
+					if(n.node.left != null) q.offer(new Node(n.node.left, (n.index << 1) - 1));
+					if(n.node.right != null) q.offer(new Node(n.node.right, n.index << 1));
+				}
+				res = Math.max(res, max - min + 1);
+			}
+			return res;
+		}
+	}
+	```

leetcode/997. Find the Town Judge.md

@@ -0,0 +1,71 @@
+## 997. Find the Town Judge
+
+### Question
+In a town, there are N people labelled from 1 to N.  There is a rumor that one of these people is secretly the town judge.
+
+If the town judge exists, then:
+* The town judge trusts nobody.
+* Everybody (except for the town judge) trusts the town judge.
+* There is exactly one person that satisfies properties 1 and 2.
+
+You are given trust, an array of pairs trust[i] = [a, b] representing that the person labelled a trusts the person labelled b.
+
+If the town judge exists and can be identified, return the label of the town judge.  Otherwise, return -1.
+
+```
+Example 1:
+
+Input: N = 2, trust = [[1,2]]
+Output: 2
+
+Example 2:
+
+Input: N = 3, trust = [[1,3],[2,3]]
+Output: 3
+
+Example 3:
+
+Input: N = 3, trust = [[1,3],[2,3],[3,1]]
+Output: -1
+
+Example 4:
+
+Input: N = 3, trust = [[1,2],[2,3]]
+Output: -1
+
+Example 5:
+
+Input: N = 4, trust = [[1,3],[1,4],[2,3],[2,4],[4,3]]
+Output: 3
+```
+ 
+Note:
+
+1. 1 <= N <= 1000
+2. trust.length <= 10000
+3. trust[i] are all different
+4. trust[i][0] != trust[i][1]
+5. 1 <= trust[i][0], trust[i][1] <= N
+
+### Solution
+* Method 1: Indegree and outdegree of each vertex.
+	```Java
+	class Solution {
+		public int findJudge(int N, int[][] trust) {
+			int[] indegree = new int[N + 1];
+			int[] outdegree = new int[N + 1];
+			for(int[] t : trust){
+				indegree[t[1]]++;
+				outdegree[t[0]]++;
+			}
+			int res = -1;
+			for(int i = 1; i <= N; i++){
+				if(indegree[i] == N - 1 && outdegree[i] == 0){
+					if(res != -1) return -1;
+					else res = i;
+				}
+			}
+			return res;
+		}
+	}
+	```