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

Author: Botao Xiao

Diff for: 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;
+	    }
+	}
+	```

Diff for: 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;
+	    }
+	}
+	```

Diff for: 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;
+      }
+  }
+  ```

Diff for: 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;
+	    }
+	}
+	```

Diff for: 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;
+      }
+  }
+  ```

Diff for: 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];
+      }
+  }
+  ```

Diff for: leetcode/273. Integer to English Words.md

@@ -18,7 +18,7 @@ Output: "bb"
 ### Thinking:
 * Method1: Iterate center of two points.
 ** 1.Center is a character, length of palindromic string is odd.
-** 2.Center is between two characters, length of palindromic is even. 
+** 2.Center is between two characters, length of palindromic is even.
 ```Java
 	class Solution {
 	    public String longestPalindrome(String s) {
@@ -115,4 +115,60 @@ class Solution {
         return s.substring(++low, high);
     }
 }
-```
+```
+
+### Third Time
+* Method 1: O(n^3)
+	```Java
+	class Solution {
+	    public String longestPalindrome(String s) {
+	        String res = "";
+	        if(s == null || s.length() == 0) return res;
+	        for(int i = 0; i < s.length(); i++){
+	            for(int j = i + res.length(); j <= s.length(); j++){
+	                String sub = s.substring(i, j);
+	                if(isPalindrome(sub)){
+	                    res = sub;
+	                }
+	            }
+	        }
+	        return res;
+	    }
+	    private boolean isPalindrome(String s){ // O(n)
+	        int low = 0, high = s.length() - 1;
+	        char[] arr = s.toCharArray();
+	        while(low < high){
+	            if(arr[low++] != arr[high--]) return false;
+	        }
+	        return true;
+	    }
+	}
+	```
+
+* Method 2: O(n^2)
+	```Java
+	class Solution {
+	    private int low, max;
+	    private char[] arr;
+	    public String longestPalindrome(String s) {
+	        if(s == null || s.length() == 0) return s;
+	        else if(s.length() == 1) return s;
+	        arr = s.toCharArray();
+	        for(int i = 0; i < arr.length - 1; i++){
+	            expand(i, i);
+	            expand(i, i + 1);
+	        }
+	        return s.substring(low, low + max);
+	    }
+	    private void expand(int low, int high){
+	        while(low >= 0 && high < arr.length && arr[low] == arr[high]){
+	            low--;
+	            high++;
+	        }
+	        if(this.max < high - low - 1){
+	            this.low = low + 1;
+	            this.max = high - 1 - low;
+	        }
+	    }
+	}
+	```

Diff for: leetcode/287. Find the Duplicate Number.md

@@ -0,0 +1,67 @@
+## 904. Fruit Into Baskets
+
+### Question
+In a row of trees, the i-th tree produces fruit with type tree[i].
+
+You start at any tree of your choice, then repeatedly perform the following steps:
+
+Add one piece of fruit from this tree to your baskets.  If you cannot, stop.
+Move to the next tree to the right of the current tree.  If there is no tree to the right, stop.
+Note that you do not have any choice after the initial choice of starting tree: you must perform step 1, then step 2, then back to step 1, then step 2, and so on until you stop.
+
+You have two baskets, and each basket can carry any quantity of fruit, but you want each basket to only carry one type of fruit each.
+
+What is the total amount of fruit you can collect with this procedure?
+
+
+```
+Example 1:
+
+Input: [1,2,1]
+Output: 3
+Explanation: We can collect [1,2,1].
+Example 2:
+
+Input: [0,1,2,2]
+Output: 3
+Explanation: We can collect [1,2,2].
+If we started at the first tree, we would only collect [0, 1].
+Example 3:
+
+Input: [1,2,3,2,2]
+Output: 4
+Explanation: We can collect [2,3,2,2].
+If we started at the first tree, we would only collect [1, 2].
+Example 4:
+
+Input: [3,3,3,1,2,1,1,2,3,3,4]
+Output: 5
+Explanation: We can collect [1,2,1,1,2].
+If we started at the first tree or the eighth tree, we would only collect 4 fruits.
+```
+
+Note:
+* 1 <= tree.length <= 40000
+* 0 <= tree[i] < tree.length
+
+### Solution
+* Method 1: HashMap + Two pointers
+  ```Java
+  class Solution {
+      public int totalFruit(int[] tree) {
+          if(tree.length < 2) return tree.length;
+          Map<Integer, Integer> map = new HashMap<>();        
+          int start = 0, max = 0;
+          for(int i = 0; i < tree.length; i++){
+              map.put(tree[i], map.getOrDefault(tree[i], 0) + 1);
+              while(map.size() > 2){
+                  map.put(tree[start], map.get(tree[start]) - 1);
+                  if(map.get(tree[start]) == 0) map.remove(tree[start]);
+                  start++;
+              }
+              max = Math.max(max, i - start + 1);
+          }
+          return max;
+      }
+  }
+  ```