update questions

Author: maxyzli

README.md

@@ -16,6 +16,7 @@ LeetCode Solution in Java
 - [Graph](#graph)
 - [Greedy](#greedy)
 - [Backtracking](#backtracking)
+- [Divide and Conquer](#divide-and-conquer)
 - [Dynamic Programming](#dynamic-programming)
 - [Trie](#trie)
 - [Design](#design)
@@ -39,6 +40,7 @@ LeetCode Solution in Java
 
 | # | Title | Solution | Difficulty |
 |:-:|-|-|-|
+|136|[Single Number](https://leetcode.com/problems/single-number/)|[Java](bit/single-number/README.md)|Easy|
 |191|[Number of 1 Bits](https://leetcode.com/problems/number-of-1-bits/)|[Java](bit/number-of-1-bits/README.md)|Easy|
 |231|[Power of Two](https://leetcode.com/problems/power-of-two/)|[Java](bit/power-of-two/README.md)|Easy|
 |371|[Sum of Two Integers](https://leetcode.com/problems/sum-of-two-integers/)|[Java](bit/sum-of-two-integers/README.md)|Medium|
@@ -86,13 +88,15 @@ LeetCode Solution in Java
 |345|[Reverse Vowels of a String](https://leetcode.com/problems/reverse-vowels-of-a-string/)|[Java](array-string/reverse-vowels-of-a-string/README.md)|Easy|
 |349|[Intersection of Two Arrays](https://leetcode.com/problems/intersection-of-two-arrays/)|[Java](array-string/intersection-of-two-arrays/README.md)|Easy|
 |350|[Intersection of Two Arrays II](https://leetcode.com/problems/intersection-of-two-arrays-ii/)|[Java](array-string/intersection-of-two-arrays-ii/README.md)|Easy|
+|414|[Third Maximum Number (Classic)](https://leetcode.com/problems/third-maximum-number/)|[Java](array-string/third-maximum-number/README.md)|Easy|
 |442|[Find All Duplicates in an Array](https://leetcode.com/problems/find-all-duplicates-in-an-array/)|[Java](array-string/find-all-duplicates-in-an-array/README.md)|Medium|
 |448|[Find All Numbers Disappeared in an Array](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/)|[Java](array-string/find-all-numbers-disappeared-in-an-array/README.md)|Easy|
 |459|[Repeated Substring Pattern](https://leetcode.com/problems/repeated-substring-pattern/)|[Java](array-string/repeated-substring-pattern/README.md)|Easy|
 |509|[Fibonacci Number](https://leetcode.com/problems/fibonacci-number/)|[Java](array-string/fibonacci-number/README.md)|Easy|
 |541|[Reverse String II](https://leetcode.com/problems/reverse-string-ii/)|[Java](array-string/reverse-string-ii/README.md)|Easy|
 |557|[Reverse Words in a String III](https://leetcode.com/problems/reverse-words-in-a-string-iii/)|[Java](array-string/reverse-words-in-a-string-iii/README.md)|Easy|
 |605|[Can Place Flowers](https://leetcode.com/problems/can-place-flowers/)|[Java](array-string/can-place-flowers/README.md)|Easy|
+|628|[Maximum Product of Three Numbers](https://leetcode.com/problems/maximum-product-of-three-numbers/)|[Java](array-string/maximum-product-of-three-numbers/README.md)|Easy|
 |665|[Non-decreasing Array](https://leetcode.com/problems/non-decreasing-array/)|[Java](array-string/non-decreasing-array/README.md)|Medium|
 |852|[Peak Index in a Mountain Array](https://leetcode.com/problems/peak-index-in-a-mountain-array/)|[Java](array-string/peak-index-in-a-mountain-array/README.md)|Easy|
 |860|[Lemonade Change](https://leetcode.com/problems/lemonade-change/)|[Java](array-string/lemonade-change/README.md)|Easy|
@@ -237,6 +241,12 @@ LeetCode Solution in Java
 |216|[Combination Sum III](https://leetcode.com/problems/combination-sum-iii/)|[Java](backtracking/combination-sum-iii/README.md)|Medium|
 |437|[Path Sum III](https://leetcode.com/problems/path-sum-iii/)|[Java](backtracking/path-sum-iii/README.md)|Medium|
 
+## Divide and Conquer
+
+| # | Title | Solution | Difficulty |
+|:-:|-|-|-|
+|493|[Reverse Pairs (Classic)](https://leetcode.com/problems/reverse-pairs/)|[Java](divide-and-conquer/reverse-pairs/README.md)|Hard|
+
 ## Dynamic Programming
 
 *Important*
@@ -264,6 +274,7 @@ LeetCode Solution in Java
 |1155|[Number of Dice Rolls With Target Sum](https://leetcode.com/problems/number-of-dice-rolls-with-target-sum/)|[Java](dynamic-programming/number-of-dice-rolls-with-target-sum/README.md)|Medium|
 
 ## Trie
+
 | # | Title | Solution | Difficulty |
 |:-:|-|-|-|
 |208|[Implement Trie (Prefix Tree)](https://leetcode.com/problems/implement-trie-prefix-tree/)|[Java](trie/implement-trie-prefix-tree/README.md)|Medium|

array-string/maximum-product-of-three-numbers/README.md

@@ -0,0 +1,44 @@
+# Maximum Product of Three Numbers
+
+## Solution 1
+
+```java
+/**
+ * Question   : 628. Maximum Product of Three Numbers
+ * Complexity : Time: O(n) ; Space: O(1)
+ * Topics     : Array
+ */
+class Solution {
+    public int maximumProduct(int[] nums) {
+        int min1 = Integer.MAX_VALUE;
+        int min2 = Integer.MAX_VALUE;
+        int max1 = Integer.MIN_VALUE;
+        int max2 = Integer.MIN_VALUE;
+        int max3 = Integer.MIN_VALUE;
+
+        for (int i = 0; i < nums.length; i++) {
+            int num = nums[i];
+
+            if (min1 > num) {
+                min2 = min1;
+                min1 = num;
+            } else if (min2 > num) {
+                min2 = num;
+            }
+
+            if (num > max1) {
+                max3 = max2;
+                max2 = max1;
+                max1 = num;
+            } else if (num > max2) {
+                max3 = max2;
+                max2 = num;
+            } else if (num > max3) {
+                max3 = num;
+            }
+        }
+
+        return Math.max(max1 * max2 * max3, max1 * min1 * min2);
+    }
+}
+```

array-string/third-maximum-number/README.md

@@ -0,0 +1,72 @@
+# Third Maximum Number
+
+## Solution 1
+
+```java
+/**
+ * Question   : Find Three Largest Number
+ * Complexity : Time: O(n) ; Space: O(1)
+ */
+public class Solution {
+    public int thirdMax(int[] array) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+
+        for (int i = 0; i < array.length; i++) {
+            int curr = array[i];
+
+            if (pq.size() < 3 && !pq.contains(curr)) {
+                pq.add(curr);
+                continue;
+            }
+
+            if (!pq.contains(curr) && curr > pq.peek()) {
+                pq.remove();
+                pq.add(curr);
+            }
+        }
+
+        if (pq.size() < 3) {
+            while (pq.size() != 1) pq.remove();
+        }
+
+        return pq.remove();
+    }
+}
+```
+
+## Solution 2
+
+```java
+/**
+ * Question   : 414. Third Maximum Number
+ * Complexity : Time: O(n) ; Space: O(1)
+ * Topics     : Array
+ */
+class Solution {
+    public int thirdMax(int[] nums) {
+        Integer first = null;
+        Integer second = null;
+        Integer third = null;
+
+        for (int i = 0; i < nums.length; i++) {
+            int num = nums[i];
+
+            if ((first == null) || (num > first)) {
+                third = second;
+                second = first;
+                first = num;
+            } else if (num != first && (second == null || num > second)) {
+                third = second;
+                second = num;
+            } else if ((num != first && num != second) && (third == null || num > third)) {
+                third = num;
+            }
+        }
+
+        if (third != null) {
+            return third;
+        }
+        return first;
+    }
+}
+```

bit/single-number/README.md

@@ -0,0 +1,20 @@
+# Single Number
+
+## Solution 1
+
+```java
+/**
+ * Question   : 136. Single Number
+ * Complexity : Time: O(n) ; Space: O(1)
+ * Topics     : Bit
+ */
+class Solution {
+    public int singleNumber(int[] nums) {
+        int res = nums[0];
+        for (int i = 1; i < nums.length; i++) {
+            res ^= nums[i];
+        }
+        return res;
+    }
+}
+```

divide-and-conquer/reverse-pairs/README.md

@@ -0,0 +1,85 @@
+# Count Inversions in an array 
+
+## Solution 1
+
+Brute Force
+
+```java
+public class Solution {
+    public int reversePairs(int[] nums) {
+        int count = 0;
+        int len = nums.length;
+        for (int i = 0; i < len - 1; i++) {
+            for (int j = i + 1; j < len; j++) {
+                if (nums[i] > nums[j]) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+}
+```
+
+## Solution 2
+
+Merge Sort
+
+```java
+/**
+ * Question   : Count Inversions in an array
+ * Complexity : Time: O(nlog(n)) ; Space: O(1)
+ * Topics     : Divide and Conquer
+ */
+public class Solution {
+    public int reversePairs(int[] arr) {
+        if (arr == null || arr.length == 0) {
+            return 0;
+        }
+        return mergeSort(arr, 0, arr.length - 1);
+    }
+
+    public int mergeSort(int[] arr, int low, int high) {
+        if (low == high) {
+            return 0;
+        }
+
+        int mid = low + (high - low) / 2;
+
+        int leftCount = mergeSort(arr, low, mid);
+        int rightCount = mergeSort(arr, mid + 1, high);
+
+        return leftCount + rightCount + merge(arr, low, mid, high);
+    }
+
+    public int merge(int[] arr, int low, int mid, int high) {
+        int[] merged = new int[high - low + 1];
+
+        int i = low, j = mid + 1, k = 0;
+
+        int inversion = 0;
+
+        while (i <= mid && j <= high) {
+            if (arr[i] <= arr[j]) {
+                merged[k++] = arr[i++];
+            } else {
+                merged[k++] = arr[j++];
+                inversion += mid - i + 1;
+            }
+        }
+        while (i <= mid) {
+            merged[k++] = arr[i++];
+        }
+        while (j <= high) {
+            merged[k++] = arr[j++];
+        }
+
+        k = 0;
+        for (; k < merged.length; k++) {
+            arr[low + k] = merged[k];
+        }
+
+        return inversion;
+    }
+}
+```