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

Author: Botao Xiao

leetcode/617. Merge Two Binary Trees.md

@@ -0,0 +1,55 @@
+## 617. Merge Two Binary Trees
+
+### Question
+Given two binary trees and imagine that when you put one of them to cover the other, some nodes of the two trees are overlapped while the others are not.
+
+You need to merge them into a new binary tree. The merge rule is that if two nodes overlap, then sum node values up as the new value of the merged node. Otherwise, the NOT null node will be used as the node of new tree.
+
+```
+Example 1:
+
+Input:
+	Tree 1                     Tree 2                  
+          1                         2                             
+         / \                       / \                            
+        3   2                     1   3                        
+       /                           \   \                      
+      5                             4   7                  
+Output:
+Merged tree:
+	     3
+	    / \
+	   4   5
+	  / \   \
+	 5   4   7
+```
+
+Note: The merging process must start from the root nodes of both trees.
+
+### Solution
+* 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 Solution {
+      public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
+          if(t1 != null && t2 != null){
+              t1.val = t1.val + t2.val;
+              t1.left = mergeTrees(t1.left, t2.left);
+              t1.right = mergeTrees(t1.right, t2.right);
+              return t1;
+          }else if(t1 != null || t2 != null){
+              return t1 != null ? t1: t2;
+          }else{
+              return null;
+          }
+      }
+  }
+  ```

leetcode/763. Partition Labels.md

@@ -0,0 +1,50 @@
+## 763. Partition Labels
+
+### Question
+A string S of lowercase letters is given. We want to partition this string into as many parts as possible so that each letter appears in at most one part, and return a list of integers representing the size of these parts.
+
+```
+Example 1:
+Input: S = "ababcbacadefegdehijhklij"
+Output: [9,7,8]
+Explanation:
+The partition is "ababcbaca", "defegde", "hijhklij".
+This is a partition so that each letter appears in at most one part.
+A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.
+```
+
+Note:
+1. S will have length in range [1, 500].
+2. S will consist of lowercase letters ('a' to 'z') only.
+
+### Solution
+* Method 1: Greedy
+  ```Java
+  class Solution {
+      public List<Integer> partitionLabels(String S) {
+          int len = S.length();
+          char[] arr = S.toCharArray();
+          int cur = 0, last = 0, temp = 0, count = 0;
+          Map<Character, Integer> map = findLast(arr);
+          List<Integer> result = new ArrayList<>();
+          while(cur < len){
+              last = map.get(arr[cur]);
+              temp = cur;
+              while(temp < last){
+                  last = Math.max(last, map.get(arr[++temp]));
+              }
+              result.add(last - cur + 1);
+              cur = last + 1;
+          }
+          return result;
+      }
+      private Map<Character, Integer> findLast(char[] arr){
+          Map<Character, Integer> map = new HashMap<>();
+          for(int i = arr.length - 1; i >= 0; i--){
+              if(map.containsKey(arr[i])) continue;
+              map.put(arr[i], i);
+          }
+          return map;
+      }
+  }
+  ```

leetcode/929. Unique Email Addresses.md

@@ -0,0 +1,55 @@
+## 929. Unique Email Addresses
+
+### Question
+Every email consists of a local name and a domain name, separated by the @ sign.
+
+For example, in [email protected], alice is the local name, and leetcode.com is the domain name.
+
+Besides lowercase letters, these emails may contain '.'s or '+'s.
+
+If you add periods ('.') between some characters in the local name part of an email address, mail sent there will be forwarded to the same address without dots in the local name.  For example, "[email protected]" and "[email protected]" forward to the same email address.  (Note that this rule does not apply for domain names.)
+
+If you add a plus ('+') in the local name, everything after the first plus sign will be ignored. This allows certain emails to be filtered, for example [email protected] will be forwarded to [email protected].  (Again, this rule does not apply for domain names.)
+
+It is possible to use both of these rules at the same time.
+
+Given a list of emails, we send one email to each address in the list.  How many different addresses actually receive mails?
+
+
+```
+Example 1:
+
+Input: ["[email protected]","[email protected]","[email protected]"]
+Output: 2
+Explanation: "[email protected]" and "[email protected]" actually receive mails
+```
+
+Note:
+1. 1 <= emails[i].length <= 100
+2. 1 <= emails.length <= 100
+3. Each emails[i] contains exactly one '@' character.
+4. All local and domain names are non-empty.
+5. Local names do not start with a '+' character.
+
+### Solution
+* Method 1: String
+  ```Java
+  class Solution {
+      public int numUniqueEmails(String[] emails) {
+          Set<String> set = new HashSet<>();
+          for(String email : emails){
+              int index = email.indexOf('@');
+              String local = email.substring(0, index);
+              String domin = email.substring(index + 1);
+              local = local.replace(".", "");
+              index = local.indexOf("+");
+              if(index == -1){
+                  set.add(local + "@" + domin);
+              }else{
+                  set.add(local.substring(0, index) + "@" + domin);
+              }
+          }
+          return set.size();
+      }
+  }
+  ```