[LEET-0000] clean up

Author: fishercoder1534

leetcode-algorithms/README.md

@@ -60,6 +60,8 @@
 |362|[Design Hit Counter](https://leetcode.com/problems/design-hit-counter/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/DesignHitCounter.java)| O(1) amortized|O(k) | Medium| Design
 |361|[Bomb Enemy](https://leetcode.com/problems/bomb-enemy/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/BombEnemies.java)| O(?)|O(?) | Medium| 
 |359|[Logger Rate Limiter](https://leetcode.com/problems/logger-rate-limiter/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/LoggerRateLimiter.java)| amortized O(1)|O(k) | Easy| HashMap
+|357|[Count Numbers with Unique Digits](https://leetcode.com/problems/count-numbers-with-unique-digits/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/CountNumbersWithUniqueDigits.java)| O(?)|O(?) | Medium|
+|353|[Design Snake Game](https://leetcode.com/problems/design-snake-game/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/DesignSnakeGame.java)| O(?)|O(?) | Medium|
 |351|[Android Unlock Patterns](https://leetcode.com/problems/android-unlock-patterns/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/AndroidUnlockPatterns.java)| O(?)|O(?) | Medium|
 |350|[Intersection of Two Arrays II](https://leetcode.com/problems/intersection-of-two-arrays-ii/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/IntersectionOfTwoArraysII.java)| O(m+n)|O((m+n)) could be optimized | Easy| HashMap, Binary Search
 |349|[Intersection of Two Arrays](https://leetcode.com/problems/intersection-of-two-arrays/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/IntersectionOfTwoArrays.java)| O(m+n)|O(min(m,n)) | Easy| Two Pointers, Binary Search
@@ -75,6 +77,7 @@
 |325|[Maximum Size Subarray Sum Equals k](https://leetcode.com/problems/maximum-size-subarray-sum-equals-k/)|[Solution] | O(n)|O(n) | Medium| HashMap
 |323|[Number of Connected Components in an Undirected Graph](https://leetcode.com/problems/number-of-connected-components-in-an-undirected-graph/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/NumberOfConnectedComponentsInAnUndirectedGraph.java)| O(?)|O(?)| Medium|
 |322|[Coin Change](https://leetcode.com/problems/coin-change/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/CoinChange.java)| O(?)|O(?) | Medium|
+|321|[Create Maximum Number](https://leetcode.com/problems/create-maximum-number/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/CreateMaximumNumber.java)| O(?)|O(?) | Hard
 |317|[Shortest Distance from All Buildings](https://leetcode.com/problems/shortest-distance-from-all-buildings/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/ShortestDistanceFromAllBuildings.java)| O(?)|O(?) | Hard| 
 |315|[Count of Smaller Numbers After Self](https://leetcode.com/problems/count-of-smaller-numbers-after-self/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/CountOfSmallerNumbersAfterSelf.java)| O(?)|O(?)| Hard| Tree
 |314|[Binary Tree Vertical Order Traversal](https://leetcode.com/problems/binary-tree-vertical-order-traversal/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/BinaryTreeVerticalOrderTraversal.java)| O(n)|O(n) | Medium| HashMap, BFS
@@ -201,13 +204,15 @@
 |141|[Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/LinkedListCycle.java)| O(n)|O(1) | Easy| Linked List
 |140|[Word Break II](https://leetcode.com/problems/word-break-ii/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/WordBreakII.java)| ? |O(n^2) | Hard| Backtracking/DFS
 |139|[Word Break](https://leetcode.com/problems/word-break/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/WordBreak.java)| O(n^2)|O(n) | Medium| DP
+|138|[Copy List with Random Pointer](https://leetcode.com/problems/copy-list-with-random-pointer/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/CopyListWithRandomPointer.java)| O(?)|O(?) | Medium| 
 |137|[Single Number II](https://leetcode.com/problems/single-number-ii/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/SingleNumberII.java)| O(n)|O(n) | Medium|
 |135|[Candy](https://leetcode.com/problems/candy/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/Candy.java)| O(n)|O(1) | Hard| Greedy
 |133|[Clone Graph](https://leetcode.com/problems/clone-graph/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/CloneGraph.java)| O(n)|O(n) | Medium| HashMap, BFS 
 |132|[Implement Queue using Stacks](https://leetcode.com/problems/implement-queue-using-stacks/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/ImplementQueueUsingStacks.java)| O(n)|O(n) | Easy| Stack, Queue
 |129|[Sum Root to Leaf Numbers](https://leetcode.com/problems/sum-root-to-leaf-numbers/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/SumRootToLeafNumbers.java)| O(n)|O(h) | Medium| DFS
 |125|[Valid Palindrome](https://leetcode.com/problems/valid-palindrome/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/ValidPalindrome.java)| O(n)|O(1) | Easy| Two Pointers
 |124|[Binary Tree Maximum Path Sum](https://leetcode.com/problems/binary-tree-maximum-path-sum/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/BinaryTreeMaximumPathSum.java)| O(n)|O(h) | Hard | Tree
+|123|[Best Time to Buy and Sell Stock III](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/BestTimeToBuyAndSellStockIII.java)| O(?)|O(?) | Hard |
 |122|[Best Time to Buy and Sell Stock II](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/BestTimeToBuyAndSellStockII.java)| O(n)|O(1) | Medium | Greedy
 |121|[Best Time to Buy and Sell Stock](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/BestTimeToBuyAndSellStock.java)| O(n)|O(1) | Easy| DP
 |120|[Triangle](https://leetcode.com/problems/triangle/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/Triangle.java)| O(m*n)|O(n) | Medium| DP
@@ -223,12 +228,15 @@
 |109|[Convert Sorted List to Binary Search Tree](https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/ConvertSortedListtoBinarySearchTree.java)| O(n)|O(h) | Medium | DFS, Recursion
 |108|[Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/ConvertSortedArraytoBinarySearchTree.java)| O(n)|O(h) | Medium| Tree
 |107|[Binary Tree Level Order Traversal II](https://leetcode.com/problems/binary-tree-level-order-traversal-ii/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/BinaryTreeLevelOrderTraversalII.java)| O(nlogn)|O(h) | Easy| BFS
+|105|[Construct Binary Tree from Preorder and Inorder Traversal](https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/ConstructBinaryTreefromPreorderandInorderTraversal.java)| O(?)|O(?) | Medium| 
 |104|[Maximum Depth of Binary Tree](https://leetcode.com/problems/maximum-depth-of-binary-tree/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/MaximumDepthOfBinaryTree.java)| O(n)|O(h) | Easy| DFS
 |103|[Binary Tree Zigzag Level Order Traversal](https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/BinaryTreeZigzagLevelOrderTraversal.java)| O(n)|O(h) | Medium| BFS,DFS
 |102|[Binary Tree Level Order Traversal](https://leetcode.com/problems/binary-tree-level-order-traversal/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/BinaryTreeLevelOrderTraversal.java)| O(n)|O(h) | Easy| BFS
+|99|[Recover Binary Search Tree](https://leetcode.com/problems/recover-binary-search-tree/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/RecoverBinarySearchTree.java) | O(?) | O(?) | Hard |
 |98|[Validate Binary Search Tree](https://leetcode.com/problems/validate-binary-search-tree/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/ValidateBinarySearchTree.java) | O(n) | O(h) | Medium | DFS/Recursion
 |97|[Interleaving String](https://leetcode.com/problems/interleaving-string/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/InterleavingString.java)| O(?)|O(?) | Hard| DP
 |96|[Unique Binary Search Trees](https://leetcode.com/problems/unique-binary-search-trees/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/UniqueBinarySearchTrees.java) | O(n^2) | O(n) | Medium | Recursion, DP
+|95|[Unique Binary Search Trees II](https://leetcode.com/problems/unique-binary-search-trees-ii/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/UniqueBinarySearchTreesII.java) | O(?) | O(?) | Medium | Recursion
 |94|[Binary Tree Inorder Traversal](https://leetcode.com/problems/binary-tree-inorder-traversal/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/BinaryTreeInorderTraversal.java)| O(n)|O(h) | Medium| Binary Tree
 |92|[Reverse Linked List II](https://leetcode.com/problems/reverse-linked-list-ii/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/ReverseLinkedListII.java)| O(n)|O(1) | Medium
 |91|[Decode Ways](https://leetcode.com/problems/decode-ways/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/DecodeWays.java)| O(n)|O(n) | Medium| DP

leetcode-algorithms/src/main/java/com/stevesun/solutions/BestTimeToBuyAndSellStockIII.java

@@ -2,9 +2,6 @@
 
 
 /**123. Best Time to Buy and Sell Stock III  QuestionEditorial Solution  My Submissions
-Total Accepted: 62880
-Total Submissions: 231914
-Difficulty: Hard
 Say you have an array for which the ith element is the price of a given stock on day i.
 
 Design an algorithm to find the maximum profit. You may complete at most two transactions.

leetcode-algorithms/src/main/java/com/stevesun/solutions/ConstructBinaryTreefromPreorderandInorderTraversal.java

@@ -0,0 +1,41 @@
+package com.stevesun.solutions;
+
+import com.stevesun.common.classes.TreeNode;
+
+/**Given preorder and inorder traversal of a tree, construct the binary tree.
+
+ Note:
+ You may assume that duplicates do not exist in the tree.*/
+public class ConstructBinaryTreefromPreorderandInorderTraversal {
+
+	public static TreeNode buildTree(int[] preorder, int[] inorder) {
+		if (preorder.length == 0)
+			return null;
+		return buildTree(preorder, inorder, 0, 0, inorder.length - 1);
+	}
+
+	private static TreeNode buildTree(int[] preorder, int[] inorder,
+			int preorderIndex, int start, int end) {
+		if (start > end)
+			return null;
+		TreeNode node = new TreeNode(preorder[preorderIndex]);
+		int inorderIndex = findInorderIndex(inorder, start, end,
+				preorder[preorderIndex]);
+		int leftTreeSize = inorderIndex - start;
+		int rightTreeSize = end - inorderIndex;
+		node.left = buildTree(preorder, inorder, preorderIndex + 1, start,
+				inorderIndex - 1);
+		node.right = buildTree(preorder, inorder, preorderIndex + leftTreeSize
+				+ 1, inorderIndex + 1, end);
+		return node;
+	}
+
+	private static int findInorderIndex(int[] inorder, int start, int end,
+			int key) {
+		for (int i = start; i <= end; i++) {
+			if (inorder[i] == key)
+				return i;
+		}
+		return -1;
+	}
+}

leetcode-algorithms/src/main/java/com/stevesun/solutions/CopyListWithRandomPointer.java

@@ -0,0 +1,39 @@
+package com.stevesun.solutions;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null.
+
+ Return a deep copy of the list.*/
+
+public class CopyListWithRandomPointer {
+
+    public RandomListNode copyRandomList(RandomListNode head) {
+        Map<RandomListNode, RandomListNode> map = new HashMap();
+        RandomListNode node = head;
+
+        //loop for the first time: copy the node themselves
+        while(node != null){
+            map.put(node, new RandomListNode(node.label));
+            node = node.next;
+        }
+        
+        //loop for the second time: copy random and next pointers
+        node = head;
+        while(node != null){
+            map.get(node).next = map.get(node.next);
+            map.get(node).random = map.get(node.random);
+            node = node.next;
+        }
+        
+        return map.get(head);
+    }
+}
+
+// Definition for singly-linked list with a random pointer.
+class RandomListNode {
+     int label;
+     RandomListNode next, random;
+     RandomListNode(int x) { this.label = x; }
+ };

leetcode-algorithms/src/main/java/com/stevesun/solutions/CountNumbersWithUniqueDigits.java

@@ -0,0 +1,32 @@
+package com.stevesun.solutions;
+
+/**
+ * Given a non-negative integer n, count all numbers with unique digits, x, where 0 ≤ x < 10n.
+
+ Example:
+ Given n = 2, return 91. (The answer should be the total numbers in the range of 0 ≤ x < 100, excluding [11,22,33,44,55,66,77,88,99])
+
+ Hint:
+
+ A direct way is to use the backtracking approach.
+ Backtracking should contains three states which are (the current number, number of steps to get that number and a bitmask which represent which number is marked as visited so far in the current number). Start with state (0,0,0) and count all valid number till we reach number of steps equals to 10n.
+ This problem can also be solved using a dynamic programming approach and some knowledge of combinatorics.
+ Let f(k) = count of numbers with unique digits with length equals k.
+ f(1) = 10, ..., f(k) = 9 * 9 * 8 * ... (9 - k + 2) [The first factor is 9 because a number cannot start with 0].
+ */
+public class CountNumbersWithUniqueDigits {
+
+    public int countNumbersWithUniqueDigits(int n) {
+        if (n == 0)     return 1;
+        int res = 10;
+        int uniqueDigits = 9;
+        int availableNumber = 9;
+        while (n-- > 1 && availableNumber > 0) {
+            uniqueDigits = uniqueDigits * availableNumber;
+            res += uniqueDigits;
+            availableNumber--;
+        }
+        return res;
+    }
+
+}

leetcode-algorithms/src/main/java/com/stevesun/solutions/CreateMaximumNumber.java

@@ -0,0 +1,61 @@
+package com.stevesun.solutions;
+
+/**
+ * Given two arrays of length m and n with digits 0-9 representing two numbers. Create the maximum number of length k <= m + n from digits of the two. The relative order of the digits from the same array must be preserved. Return an array of the k digits. You should try to optimize your time and space complexity.
+
+ Example 1:
+ nums1 = [3, 4, 6, 5]
+ nums2 = [9, 1, 2, 5, 8, 3]
+ k = 5
+ return [9, 8, 6, 5, 3]
+
+ Example 2:
+ nums1 = [6, 7]
+ nums2 = [6, 0, 4]
+ k = 5
+ return [6, 7, 6, 0, 4]
+
+ Example 3:
+ nums1 = [3, 9]
+ nums2 = [8, 9]
+ k = 3
+ return [9, 8, 9]
+ */
+public class CreateMaximumNumber {
+    public int[] maxNumber(int[] nums1, int[] nums2, int k) {
+        int n = nums1.length;
+        int m = nums2.length;
+        int[] ans = new int[k];
+        for(int i = Math.max(0, k-m); i <= k && i <= n; ++i){//what is this and why?
+            int[] candidate = merge(maxArray(nums1, i), maxArray(nums2, k-i), k);
+            if(greater(candidate, 0, ans, 0)) ans = candidate;
+        }
+        return ans;
+    }
+
+    private boolean greater(int[] nums1, int i, int[] nums2, int j) {
+        while(i < nums1.length && j < nums2.length && nums1[i] == nums2[j]){
+            i++;
+            j++;
+        }
+        return j == nums2.length || (i < nums1.length && nums1[i] > nums2[j]);
+    }
+
+    private int[] merge(int[] nums1, int[] nums2, int k) {
+        int[] ans = new int[k];
+        for(int i = 0, j = 0, r = 0; r < k; r++){
+            ans[r] = greater(nums1, i, nums2, j) ? nums1[i++] : nums2[j++];
+        }
+        return ans;
+    }
+
+    private int[] maxArray(int[] nums, int k) {
+        int n = nums.length;
+        int[] ans = new int[k];
+        for(int i = 0, j = 0; i < n; i++){
+            while(n - i + j > k && j > 0 && ans[j-1] < nums[i]) j--;
+            if(j < k) ans[j++] = nums[i];
+        }
+        return ans;
+    }
+}