[Function add]

Seanforfun · Seanforfun · commit c56449378b8f · 2019-07-02T13:53:48.000-04:00
1. Add leetcode solutions with tag amazon.
diff --git a/leetcode/556. Next Greater Element III.md b/leetcode/556. Next Greater Element III.md
@@ -0,0 +1,48 @@
+## 556. Next Greater Element III
+
+### Question
+Given a positive 32-bit integer n, you need to find the smallest 32-bit integer which has exactly the same digits existing in the integer n and is greater in value than n. If no such positive 32-bit integer exists, you need to return -1.
+
+```
+Example 1:
+Input: 12
+Output: 21
+
+Example 2:
+Input: 21
+Output: -1
+```
+
+### Solution
+* Method 1: Math
+    1. Find the position to swap: traversal from right to left, find the first index whose value is smaller than its right index value. If no such index, return -1, which means current value is the maximum value can be represented by current numbers.
+    2. Swap the number in that index with the first number bigger than current one, traversal from right to the left.
+    3. Sort the values at right side of that index in ascending order.
+    ```Java
+    class Solution {
+        public int nextGreaterElement(int n) {
+            String s = n + "";
+            char[] arr = s.toCharArray();
+            int len = s.length(), i = len - 2;
+            for(; i >= 0; i--){
+                if(arr[i] < arr[i + 1]) break;
+            }
+            if(i < 0) return -1;
+            for(int j = len - 1; j > i; j--){
+                if(arr[j] > arr[i]){
+                    char temp = arr[i];
+                    arr[i] = arr[j];
+                    arr[j] = temp;
+                    break;
+                }
+            }
+            char[] sub = Arrays.copyOfRange(arr, i + 1, len);
+            Arrays.sort(sub);
+            for(int j = i + 1; j < len; j++){
+                arr[j] = sub[j - i - 1];
+            }
+            long res = Long.parseLong(new String(arr));
+            return res > Integer.MAX_VALUE ? -1: (int)res;
+        }
+    }
+    ```
diff --git a/leetcode/636. Exclusive Time of Functions.md b/leetcode/636. Exclusive Time of Functions.md
@@ -65,4 +65,33 @@ Note:
             return result;
         }
     }
+	```
+
+### Amazon Session
+* Method 1: Stack
+	```Java
+	class Solution {
+		public int[] exclusiveTime(int n, List<String> logs) {
+			int[] res = new int[n];
+			int currentTime = 0;
+			Stack<Integer> stack = new Stack<>();
+			for(String log: logs){
+				String[] tokens = log.split(":");
+				int id = Integer.parseInt(tokens[0]);
+				int time = Integer.parseInt(tokens[2]);
+				if(tokens[1].equals("start")){
+					if(!stack.isEmpty()){	//current is begin, we need to update the previous id.
+						int preId = stack.peek();
+						res[preId] += time - currentTime - 1;
+					}
+					stack.push(id);
+				}else{
+					int preId = stack.pop();
+					res[preId] += time - currentTime + 1;
+				}
+				currentTime = time;
+			}
+			return res;
+		}
+	}
 	```
diff --git a/leetcode/653. Two Sum IV - Input is a BST.md b/leetcode/653. Two Sum IV - Input is a BST.md
@@ -61,4 +61,25 @@ Output: False
             }
         }
     }
-    ```
+    ```
+
+### Amazon Session
+* Method 1: dfs
+	```Java	
+	class Solution {
+		private Set<Integer> set;
+		private int target;
+		public boolean findTarget(TreeNode root, int k) {
+			if(root == null) return false;
+			this.set = new HashSet<>();
+			this.target = k;
+			return dfs(root);
+		}
+		private boolean dfs(TreeNode node){
+			if(node == null) return false;
+			if(set.contains(this.target - node.val)) return true;
+			set.add(node.val);
+			return dfs(node.left) || dfs(node.right);
+		}
+	}
+	```
