[Function add]

1. Add leetcode solutions with tag amazon.

Author: Seanforfun

Diff for: leetcode/116. Populating Next Right Pointers in Each Node.md

@@ -104,4 +104,46 @@ public class Solution {
         }
     }
 }
-```
+```
+
+### Amazon Session
+* Method 1: BFS
+	```Java
+	/*
+	// Definition for a Node.
+	class Node {
+		public int val;
+		public Node left;
+		public Node right;
+		public Node next;
+
+		public Node() {}
+
+		public Node(int _val,Node _left,Node _right,Node _next) {
+			val = _val;
+			left = _left;
+			right = _right;
+			next = _next;
+		}
+	};
+	*/
+	class Solution {
+		public Node connect(Node root) {
+			if(root == null) return root;
+			Queue<Node> q = new LinkedList<>();
+			q.offer(root);
+			while(!q.isEmpty()){
+				Queue<Node> next = new LinkedList<>();
+				int size = q.size();
+				for(int sz = 0; sz < size; sz++){
+					Node cur = q.poll();
+					cur.next = q.isEmpty() ? null: q.peek();
+					if(cur.left != null) next.offer(cur.left);
+					if(cur.right != null) next.offer(cur.right);
+				}
+				q = next;
+			}
+			return root;
+		}
+	}
+	```

Diff for: leetcode/252. Meeting Rooms.md

@@ -57,3 +57,21 @@ public class MeetingRooms {
 	    }
 	}
 	```
+
+### Amazon Session
+* Method 1: Sort and judge
+	```Java
+	class Solution {
+		public boolean canAttendMeetings(int[][] intervals) {
+			if(intervals == null) return false;
+			if(intervals.length == 0) return true;
+			Arrays.sort(intervals, (a, b)->{
+				return a[0] == b[0] ? a[1] - b[1]: a[0] - b[0];
+			});
+			for(int i = 1; i < intervals.length; i++){
+				if(intervals[i][0] < intervals[i - 1][1]) return false;
+			}
+			return true;
+		}
+	}
+	```

Diff for: leetcode/692. Top K Frequent Words.md

@@ -64,3 +64,35 @@ Follow up:
       }
   }
   ```
+
+### Amazon Session
+* Method 1: Map + PriorityQueue
+	```Java
+	class Solution {
+		private static class Node{
+			String word;
+			int count;
+			public Node(String word, int count){
+				this.word = word;
+				this.count = count;
+			}
+		}
+		public List<String> topKFrequent(String[] words, int k) {
+			List<String> result = new ArrayList<>();        
+			Map<String, Integer> map = new HashMap<>();
+			for(String word: words){
+				map.put(word, map.getOrDefault(word, 0) + 1);
+			}
+			PriorityQueue<Node> pq = new PriorityQueue<>((a, b)->{
+				return a.count != b.count ? b.count - a.count: a.word.compareTo(b.word);
+			});
+			for(Map.Entry<String, Integer> entry: map.entrySet()){
+				pq.offer(new Node(entry.getKey(), entry.getValue()));
+			}
+			while(k-- > 0){
+				result.add(pq.poll().word);
+			}
+			return result;
+		}
+	}
+	```

Diff for: leetcode/847. Shortest Path Visiting All Nodes.md

@@ -62,5 +62,38 @@ Note:
   }
   ```
 
+### Amazon Session
+* Method 1: bfs + bit manipulation
+	```Java
+	class Solution {
+		public int shortestPathLength(int[][] graph) {
+			int len = graph.length;
+			boolean[][] visited = new boolean[len][1 << len];
+			int expect = (1 << len) - 1;
+			Queue<int[]> q = new LinkedList<>();
+			for(int i = 0; i < len; i++){
+				q.offer(new int[]{i, 1 << i});
+			}
+			int step = -1;
+			while(!q.isEmpty()){
+				step++;
+				int size = q.size();
+				for(int sz = 0; sz < size; sz++){
+					int[] cur = q.poll();
+					int node = cur[0];
+					int state = cur[1];
+					if(state == expect) return step;
+					if(visited[node][state]) continue;
+					visited[node][state] = true;
+					for(int next: graph[node]){                    
+						q.offer(new int[]{next, state | (1 <<next)});
+					}
+				}
+			}
+			return step;
+		}
+	}
+	```
+	
 ### Reference
 1. [花花酱 LeetCode 847. Shortest Path Visiting All Nodes](http://zxi.mytechroad.com/blog/graph/leetcode-847-shortest-path-visiting-all-nodes/)