[Function add]:1. Add leetcode solutions with tag amazon.

Author: Botao Xiao

leetcode/126. Word Ladder II.md

@@ -138,4 +138,66 @@ Explanation: The endWord "cog" is not in wordList, therefore no possible transfo
 			}
 		}
 	}
-	```
+	```
+
+### Second Time
+* Method 1: bfs + dfs
+  ```Java
+  class Solution {
+      private List<List<String>> result;
+      private Map<String, List<String>> map;
+      public List<List<String>> findLadders(String beginWord, String endWord, List<String> wordList) {
+          Set<String> wordSet = new HashSet<>(wordList);
+          wordSet.remove(beginWord);
+          this.result = new ArrayList<>();
+          if(!wordSet.contains(endWord)) return this.result;
+          this.map = new HashMap<>();
+          Queue<String> q = new LinkedList<>();
+          q.offer(beginWord);
+          boolean found = false;
+          int len = beginWord.length();
+          while(!found && !q.isEmpty()){
+              int size = q.size();
+              Set<String> nextLevel = new HashSet<>();
+              for(int i = 0; i < size; i++){
+                  String temp = q.poll();
+                  if(temp.equals(endWord)) found = true;
+                  char[] arr = temp.toCharArray();
+                  for(int j = 0; j < len; j++){
+                      char origin = arr[j];
+                      for(char c = 'a'; c <= 'z'; c++){
+                          if(c == origin) continue;
+                          arr[j] = c;
+                          String next = new String(arr);
+                          if(wordSet.contains(next) || nextLevel.contains(next)){
+                              List<String> list = map.containsKey(temp) ? map.get(temp): new ArrayList<>();
+                              list.add(next);
+                              map.put(temp, list);
+                              nextLevel.add(next);
+                              if(wordSet.contains(next)) q.offer(next);
+                              wordSet.remove(next);
+                          }
+                      }
+                      arr[j] = origin;
+                  }
+              }
+          }
+          List<String> temp = new ArrayList<>();
+          temp.add(beginWord);
+          dfs(temp, endWord, beginWord);
+          return this.result;
+      }
+      private void dfs(List<String> temp, String end, String cur){
+          if(cur.equals(end)) this.result.add(new ArrayList<String>(temp));
+          else{
+              if(!map.containsKey(cur)) return;
+              List<String> adj = map.get(cur);
+              for(String s: adj){
+                  temp.add(s);
+                  dfs(temp, end, s);
+                  temp.remove(temp.size() - 1);
+              }
+          }
+      }
+  }
+  ```

leetcode/173. Binary Search Tree Iterator.md

@@ -143,3 +143,98 @@ public class BSTIterator {
  * while (i.hasNext()) v[f()] = i.next();
  */
 ```
+
+### Third Time
+* Method 1: Recursion
+	```Java
+	/**
+	 * Definition for a binary tree node.
+	 * public class TreeNode {
+	 *     int val;
+	 *     TreeNode left;
+	 *     TreeNode right;
+	 *     TreeNode(int x) { val = x; }
+	 * }
+	 */
+	class BSTIterator {
+	    private Queue<Integer> q;
+	    public BSTIterator(TreeNode root) {
+	        q = new LinkedList<>();
+	        inorder(root);
+	    }
+	    private void inorder(TreeNode node){
+	        if(node == null) return;
+	        inorder(node.left);
+	        q.offer(node.val);
+	        inorder(node.right);
+	    }
+
+	    /** @return the next smallest number */
+	    public int next() {
+	        return q.poll();
+	    }
+
+	    /** @return whether we have a next smallest number */
+	    public boolean hasNext() {
+	        return !q.isEmpty();
+	    }
+	}
+
+	/**
+	 * Your BSTIterator object will be instantiated and called as such:
+	 * BSTIterator obj = new BSTIterator(root);
+	 * int param_1 = obj.next();
+	 * boolean param_2 = obj.hasNext();
+	 */
+	```
+
+* Method 2: loop
+	```Java
+	/**
+	 * Definition for a binary tree node.
+	 * public class TreeNode {
+	 *     int val;
+	 *     TreeNode left;
+	 *     TreeNode right;
+	 *     TreeNode(int x) { val = x; }
+	 * }
+	 */
+	class BSTIterator {
+	    Stack<TreeNode> stack;
+	    public BSTIterator(TreeNode root) {
+	        this.stack = new Stack<>();
+	        if(root == null) return;
+	        stack.push(root);
+	        while(root.left != null){
+	            stack.push(root.left);
+	            root = root.left;
+	        }
+	    }
+
+	    /** @return the next smallest number */
+	    public int next() {
+	        TreeNode node = stack.pop();
+	        if(node.right != null){
+	            TreeNode temp = node.right;
+	            stack.push(temp);
+	            while(temp.left != null){
+	                stack.push(temp.left);
+	                temp = temp.left;
+	            }
+	        }
+	        return node.val;
+	    }
+
+	    /** @return whether we have a next smallest number */
+	    public boolean hasNext() {
+	        return !stack.isEmpty();
+	    }
+	}
+
+	/**
+	 * Your BSTIterator object will be instantiated and called as such:
+	 * BSTIterator obj = new BSTIterator(root);
+	 * int param_1 = obj.next();
+	 * boolean param_2 = obj.hasNext();
+	 */
+	```

leetcode/252. Meeting Rooms.md

@@ -1,4 +1,20 @@
 ## 252. Meeting Rooms
+
+### Question
+Given an array of meeting time intervals consisting of start and end times [[s1,e1],[s2,e2],...] (si < ei), determine if a person could attend all meetings.
+
+```
+Example 1:
+
+Input: [[0,30],[5,10],[15,20]]
+Output: false
+Example 2:
+
+Input: [[7,10],[2,4]]
+Output: true
+```
+NOTE: input types have been changed on April 15, 2019. Please reset to default code definition to get new method signature.
+
 ### Thinking:
 * Method 1:
 
@@ -17,4 +33,27 @@ public class MeetingRooms {
 		System.out.println(canAttend(t));
 	}
 }
-```
+```
+
+### Second Time
+* Method 1: Sort
+	```Java
+	class Solution {
+	    public boolean canAttendMeetings(int[][] intervals) {
+	        int len = intervals.length;
+	        int[] startTime = new int[len];
+	        int[] endTime = new int[len];
+	        int count = 0;
+	        for(int[] interval: intervals){
+	            startTime[count] = interval[0];
+	            endTime[count++] = interval[1];
+	        }
+	        Arrays.sort(startTime);
+	        Arrays.sort(endTime);
+	        for(int i = 1; i < len; i++){
+	            if(startTime[i] < endTime[i - 1]) return false;
+	        }
+	        return true;
+	    }
+	}
+	```

leetcode/346. Moving Average from Data Stream.md

@@ -0,0 +1,70 @@
+## 346. Moving Average from Data Stream
+
+### Question
+Given a stream of integers and a window size, calculate the moving average of all integers in the sliding window.
+
+```
+Example:
+
+MovingAverage m = new MovingAverage(3);
+m.next(1) = 1
+m.next(10) = (1 + 10) / 2
+m.next(3) = (1 + 10 + 3) / 3
+m.next(5) = (10 + 3 + 5) / 3
+```
+
+### Solution
+* Method 1: Array
+  ```Java
+  class MovingAverage {
+      private int[] arr;
+      private int size;
+      private int index;
+      /** Initialize your data structure here. */
+      public MovingAverage(int size) {
+          this.size = size;
+          this.arr = new int[size];
+      }
+      public double next(int val) {
+          arr[(index++) % this.size] = val;
+          double sum = 0D;
+          for(int v : arr)
+              sum += v;
+          return sum / (index <= size ? index: this.size);
+      }
+  }
+  /**
+   * Your MovingAverage object will be instantiated and called as such:
+   * MovingAverage obj = new MovingAverage(size);
+   * double param_1 = obj.next(val);
+   */
+  ```
+
+* Method 2: Queue
+  ```Java
+  class MovingAverage {
+      private Queue<Integer> q;
+      private int size;
+      private double sum;
+      /** Initialize your data structure here. */
+      public MovingAverage(int size) {
+          this.size = size;
+          q = new LinkedList<>();
+      }
+
+      public double next(int val) {
+          q.offer(val);
+          sum += val;
+          while(!q.isEmpty() && q.size() > size){
+              sum -= q.poll();
+          }
+          return sum / q.size();
+      }
+  }
+
+  /**
+   * Your MovingAverage object will be instantiated and called as such:
+   * MovingAverage obj = new MovingAverage(size);
+   * double param_1 = obj.next(val);
+   */
+  ```