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

Author: Botao Xiao

leetcode/146. LRU Cache.md

@@ -94,4 +94,37 @@ public class Solution {
         return (curA == curB) ? curA : null;
     }
 }
-```
+```
+
+### Third Time
+* Method 1: List
+	```Java
+	/**
+	 * Definition for singly-linked list.
+	 * public class ListNode {
+	 *     int val;
+	 *     ListNode next;
+	 *     ListNode(int x) {
+	 *         val = x;
+	 *         next = null;
+	 *     }
+	 * }
+	 */
+	public class Solution {
+	    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
+	        if(headA == null || headB == null) return null;
+	        ListNode cur1 = headA, cur2 = headB;
+	        int reach = 0;
+	        while(cur1 != cur2){
+	            cur1 = cur1.next;
+	            if(cur1 == null){
+	                cur1 = headB;
+	                if(++reach == 2) return null;
+	            }
+	            cur2 = cur2.next;
+	            if(cur2 == null) cur2 = headA;
+	        }
+	        return cur1;
+	    }
+	}
+	```

leetcode/160. Intersection of Two Linked Lists.md

@@ -136,4 +136,43 @@ class Solution {
 			return dummy.next;
 		}
 	}
-	```
+	```
+
+### Third Time
+* Method 1: List
+	```Java
+	/**
+	 * Definition for singly-linked list.
+	 * public class ListNode {
+	 *     int val;
+	 *     ListNode next;
+	 *     ListNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+	    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+	        int carry = 0;
+	        ListNode dummy = new ListNode(0), cur = dummy;
+	        while(l1 != null || l2 != null){
+	            int sum = carry;
+	            if(l1 != null && l2 != null){
+	                sum += l1.val + l2.val;
+	                l1 = l1.next;
+	                l2 = l2.next;
+	            }else if(l1 != null){
+	                sum += l1.val;
+	                l1 = l1.next;
+	            }else{
+	                sum += l2.val;
+	                l2 = l2.next;
+	            }
+	            carry = sum / 10;
+	            cur.next = new ListNode(sum % 10);
+	            cur = cur.next;
+	        }
+	        if(carry == 1)
+	            cur.next = new ListNode(1);
+	        return dummy.next;
+	    }
+	}
+	```

leetcode/2. Add Two Numbers.md

@@ -176,4 +176,51 @@ class Solution {
 			return dummy.next;
 		}
 	}
-	```
+	```
+
+### Fourth Time
+* Method 1: Divede and Conquer
+  ```Java
+  /**
+   * Definition for singly-linked list.
+   * public class ListNode {
+   *     int val;
+   *     ListNode next;
+   *     ListNode(int x) { val = x; }
+   * }
+   */
+  class Solution {
+      private ListNode[] lists;
+      public ListNode mergeKLists(ListNode[] lists) {
+          if(lists == null || lists.length == 0) return null;
+          else if(lists.length == 1) return lists[0];
+          this.lists = lists;
+          return sort(0, lists.length - 1);
+      }
+      private ListNode sort(int low, int high){
+          if(low == high) return this.lists[low];
+          int mid = low + (high - low) / 2;
+          ListNode l1 = sort(low, mid);
+          ListNode l2 = sort(mid + 1, high);
+          return merge(l1, l2);
+      }
+      private ListNode merge(ListNode l1, ListNode l2){
+          ListNode dummy = new ListNode(0), cur = dummy;
+          while(l1 != null || l2 != null){
+              if(l1 != null && l2 != null){
+                  cur.next = l1.val < l2.val ? l1: l2;
+                  if(l1.val < l2.val) l1 = l1.next;
+                  else l2 = l2.next;
+              }else if(l1 != null){
+                  cur.next = l1;
+                  l1 = l1.next;
+              }else{
+                  cur.next = l2;
+                  l2 = l2.next;
+              }
+              cur = cur.next;
+          }
+          return dummy.next;
+      }
+  }
+  ```

leetcode/218. The Skyline Problem.md

@@ -63,3 +63,23 @@ class Solution {
     }
 }
 ```
+
+### Third Time
+* Method 1: O(N) time complexity and O(1) space complexity
+	```Java
+	class Solution {
+	    public int[] productExceptSelf(int[] nums) {
+	        int[] left = new int[nums.length];
+	        left[0] = 1;
+	        for(int i = 1; i < nums.length; i++){
+	            left[i] = left[i - 1] * nums[i - 1];
+	        }
+	        int right = 1;
+	        for(int i = nums.length - 2; i >= 0; i--){
+	            right *= nums[i + 1];
+	            left[i] *= right;
+	        }
+	        return left;
+	    }
+	}
+	```

leetcode/23. Merge k Sorted Lists.md

@@ -0,0 +1,71 @@
+## 273. Integer to English Words
+
+### Question
+Convert a non-negative integer to its english words representation. Given input is guaranteed to be less than 231 - 1.
+
+```
+Example 1:
+
+Input: 123
+Output: "One Hundred Twenty Three"
+Example 2:
+
+Input: 12345
+Output: "Twelve Thousand Three Hundred Forty Five"
+Example 3:
+
+Input: 1234567
+Output: "One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven"
+Example 4:
+
+Input: 1234567891
+Output: "One Billion Two Hundred Thirty Four Million Five Hundred Sixty Seven Thousand Eight Hundred Ninety One"
+```
+
+### Solution
+* Method 1:
+  ```Java
+  class Solution {
+      private static String[] bigUnit = new String[]{"", "Thousand", "Million", "Billion"};
+      private static String[] numbers = new String[]{"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"};
+      private static String[] tens = new String[]{"", "Ten", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"};
+      private static String[] overTens = new String[]{"", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"};
+      public String numberToWords(int num) {
+          if(num == 0) return "Zero";
+          String result = "";
+          int bigUnitIndex = 0;
+          while(num > 0){
+              String temp = parseThree(num % 1000);
+              if(temp.length() != 0){
+                  result = temp
+                  + (bigUnitIndex == 0 ? "": " ")
+                  + bigUnit[bigUnitIndex]
+                  + (result.length() == 0 ? "": " ") + result;
+              }
+              bigUnitIndex++;
+              num /= 1000;
+          }
+          return result;
+      }
+      private String parseThree(int num){
+          String res = "";
+          if(num % 100 > 10 && num % 100 < 20){
+              res = overTens[num % 100 - 10];
+              num /= 100;
+          }else{
+              if(num % 10 != 0){
+                  res = numbers[num % 10];
+              }
+              num /= 10;
+              if(num % 10 != 0){
+                  res = tens[num % 10] + (res.length() == 0 ? "":" ") + res;
+              }
+              num /= 10;
+          }
+          if(num % 10 != 0){
+              res = numbers[num % 10] + " Hundred" + (res.length() == 0 ? "": " ") + res;
+          }
+          return res;
+      }
+  }
+  ```

leetcode/238. Product of Array Except Self.md

@@ -73,3 +73,23 @@ class Solution {
     }
 }
 ```
+
+### Third Time
+* Method 1: Cyclic list
+  ```Java
+  class Solution {
+      public int findDuplicate(int[] nums) {
+          int slow = 0, fast = 0;
+          do{
+              slow = nums[slow];
+              fast = nums[nums[fast]];
+          }while(nums[slow] != nums[fast]);
+          slow = 0;
+          while(nums[slow] != nums[fast]){
+              slow = nums[slow];
+              fast = nums[fast];
+          }
+          return nums[slow];
+      }
+  }
+  ```