[LEET-0000] clean up

fishercoder1534 · fishercoder1534 · commit 17c7ded39733 · 2017-02-07T18:29:02.000-08:00
diff --git a/leetcode-algorithms/README.md b/leetcode-algorithms/README.md
@@ -63,7 +63,9 @@
 |339|[Nested List Weight Sum](https://leetcode.com/problems/nested-list-weight-sum/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/NestedListWeightSum.java)| O(n)|O(h)) | Easy| DFS
 |338|[Counting Bits](https://leetcode.com/problems/counting-bits/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/CountingBits.java)| O(nlogn)|O(h) | Medium| 
 |336|[Palindrome Pairs](https://leetcode.com/problems/palindrome-pairs/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/PalindromePairs.java)| O(n^2)|O(n) | Hard|
+|334|[Increasing Triplet Subsequence](https://leetcode.com/problems/increasing-triplet-subsequence/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/IncreasingTripletSubsequence.java)| O(n^2)|O(1) | Medium|
 |333|[Largest BST Subtree](https://leetcode.com/problems/largest-bst-subtree/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/LargestBSTSubtree.java)| O(n)|O(n) | Medium| 
+|329|[Longest Increasing Path in a Matrix](https://leetcode.com/problems/longest-increasing-path-in-a-matrix/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/LongestIncreasingPathInAMatrix.java)| O(?)|O(?) | Hard|
 |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|
 |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| 
@@ -88,12 +90,14 @@
 |286|[Walls and Gates](https://leetcode.com/problems/walls-and-gates/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/WallsAndGates.java)| O(m*n)|O(g) | Medium| BFS
 |285|[Inorder Successor In BST](https://leetcode.com/problems/inorder-successor-in-bst/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/InorderSuccessorInBST.java)| O(h)|O(1) | Medium|
 |283|[Move Zeroes](https://leetcode.com/problems/move-zeroes/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/MoveZeroes.java)| O(n)|O(1) | Easy| 
+|282|[Expression Add Operators](https://leetcode.com/problems/expression-add-operators/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/ExpressionAddOperators.java)| O(?)|O(?) | Hard|
 |281|[Zigzag Iterator](https://leetcode.com/problems/zigzag-iterator/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/ZigzagIterator.java)| O(n)|O(n) | Medium|
 |280|[Wiggle Sort](https://leetcode.com/problems/wiggle-sort/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/WiggleSort.java)| O(n)|O(1) | Medium|
 |279|[Perfect Squares](https://leetcode.com/problems/perfect-squares/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/PerfectSquares.java)| O(n)|O(1) | Medium| 
 |278|[First Bad Version](https://leetcode.com/problems/first-bad-version/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/FirstBadVersion.java)| O(logn)|O(1) | Easy| Binary Search
 |277|[Find the Celebrity](https://leetcode.com/problems/find-the-celebrity/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/FindtheCelebrity.java)| O(n)|O(1) | Medium| 
 |276|[Paint Fence](https://leetcode.com/problems/paint-fence/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/PaintFence.java)| O(n)|O(1) | Easy| DP
+|274|[H-Index](https://leetcode.com/problems/h-index/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/HIndex.java)| O(nlogn)|O(1) | Medium| 
 |273|[Integer to English Words](https://leetcode.com/problems/integer-to-english-words/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/IntegertoEnglishWords.java)| O(n)|O(1) | Hard| 
 |272|[Closest Binary Search Tree Value II](https://leetcode.com/problems/closest-binary-search-tree-value-ii/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/ClosestBinarySearchTreeValueII.java)| O(h+k)|O(h) | Hard| Stack
 |271|[Encode and Decode Strings](https://leetcode.com/problems/encode-and-decode-strings/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/EncodeandDecodeStrings.java)| O(n)|O(1) | Medium| 
diff --git a/leetcode-algorithms/src/main/java/com/stevesun/solutions/ExpressionAddOperators.java b/leetcode-algorithms/src/main/java/com/stevesun/solutions/ExpressionAddOperators.java
@@ -0,0 +1,51 @@
+package com.stevesun.solutions;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Given a string that contains only digits 0-9 and a target value, return all possibilities to add binary operators (not unary) +, -, or * between the digits so they evaluate to the target value.
+
+ Examples:
+ "123", 6 -> ["1+2+3", "1*2*3"]
+ "232", 8 -> ["2*3+2", "2+3*2"]
+ "105", 5 -> ["1*0+5","10-5"]
+ "00", 0 -> ["0+0", "0-0", "0*0"]
+ "3456237490", 9191 -> []
+ */
+public class ExpressionAddOperators {
+
+    public List<String> addOperators(String num, int target) {
+        List<String> res = new ArrayList<String>();
+        StringBuilder sb = new StringBuilder();
+        dfs(res, sb, num, 0, target, 0, 0);
+        return res;
+
+    }
+
+    private void dfs(List<String> res, StringBuilder sb, String num, int pos, int target, long prev, long multi) {
+        if(pos == num.length()){
+            if(target == prev) res.add(sb.toString());
+            return;
+        }
+        for(int i = pos; i < num.length(); i++){
+            if(num.charAt(pos) == '0' && i != pos) break;
+            long curr = Long.parseLong(num.substring(pos, i+1));
+            int len = sb.length();
+            if(pos == 0){
+                dfs(res, sb.append(curr), num, i+1, target, curr, curr);
+                sb.setLength(len);
+            } else {
+                dfs(res, sb.append("+").append(curr), num, i+1, target, prev+curr, curr);
+                sb.setLength(len);
+
+                dfs(res, sb.append("-").append(curr), num, i+1, target, prev-curr, -curr);
+                sb.setLength(len);
+
+                dfs(res, sb.append("*").append(curr), num, i+1, target, prev - multi + multi*curr, multi*curr);
+                sb.setLength(len);
+            }
+        }
+    }
+
+}
diff --git a/leetcode-algorithms/src/main/java/com/stevesun/solutions/HIndex.java b/leetcode-algorithms/src/main/java/com/stevesun/solutions/HIndex.java
@@ -0,0 +1,34 @@
+package com.stevesun.solutions;
+
+import java.util.Arrays;
+
+/**
+ * Given an array of citations (each citation is a non-negative integer) of a researcher, write a function to compute the researcher's h-index.
+
+ According to the definition of h-index on Wikipedia: "A scientist has index h if h of his/her N papers have at least h citations each, and the other N − h papers have no more than h citations each."
+
+ For example, given citations = [3, 0, 6, 1, 5], which means the researcher has 5 papers in total and each of them had received 3, 0, 6, 1, 5 citations respectively. Since the researcher has 3 papers with at least 3 citations each and the remaining two with no more than 3 citations each, his h-index is 3.
+
+ Note: If there are several possible values for h, the maximum one is taken as the h-index.
+
+ Hint:
+
+ An easy approach is to sort the array first.
+ What are the possible values of h-index?
+ A faster approach is to use extra space.
+ */
+public class HIndex {
+
+    public int hIndex(int[] citations) {
+        if(citations == null || citations.length == 0)
+            return 0;
+
+        Arrays.sort(citations);
+        for(int i = 0; i < citations.length; i++){
+            if(citations[i] >= citations.length - i)
+                return citations.length - i;
+        }
+        return 0;
+    }
+
+}
diff --git a/leetcode-algorithms/src/main/java/com/stevesun/solutions/IncreasingTripletSubsequence.java b/leetcode-algorithms/src/main/java/com/stevesun/solutions/IncreasingTripletSubsequence.java
@@ -0,0 +1,35 @@
+package com.stevesun.solutions;
+
+/**
+ * Given an unsorted array return whether an increasing subsequence of length 3 exists or not in the array.
+
+ Formally the function should:
+ Return true if there exists i, j, k
+ such that arr[i] < arr[j] < arr[k] given 0 ≤ i < j < k ≤ n-1 else return false.
+ Your algorithm should run in O(n) time complexity and O(1) space complexity.
+
+ Examples:
+ Given [1, 2, 3, 4, 5],
+ return true.
+
+ Given [5, 4, 3, 2, 1],
+ return false.
+ */
+public class IncreasingTripletSubsequence {
+
+    public boolean increasingTriplet(int[] nums) {
+        if(nums == null || nums.length == 0) return false;
+        int small = nums[0], medium = Integer.MAX_VALUE;
+        for(int i = 1; i < nums.length; i++){
+            small = Math.min(small, nums[i-1]);
+            if(nums[i] > small){
+                medium = Math.min(medium, nums[i]);
+                for(int j = i+1; j < nums.length; j++){
+                    if(nums[j] > nums[i] || nums[j] > medium) return true;
+                }
+            }
+        }
+        return false;
+    }
+
+}
diff --git a/leetcode-algorithms/src/main/java/com/stevesun/solutions/LongestIncreasingPathInAMatrix.java b/leetcode-algorithms/src/main/java/com/stevesun/solutions/LongestIncreasingPathInAMatrix.java
@@ -1,9 +1,31 @@
 package com.stevesun.solutions;
 
+/**Given an integer matrix, find the length of the longest increasing path.
+
+ From each cell, you can either move to four directions: left, right, up or down. You may NOT move diagonally or move outside of the boundary (i.e. wrap-around is not allowed).
+
+ Example 1:
+
+ nums = [
+ [9,9,4],
+ [6,6,8],
+ [2,1,1]
+ ]
+ Return 4
+ The longest increasing path is [1, 2, 6, 9].
+
+ Example 2:
+
+ nums = [
+ [3,4,5],
+ [3,2,6],
+ [2,2,1]
+ ]
+ Return 4
+ The longest increasing path is [3, 4, 5, 6]. Moving diagonally is not allowed.*/
 public class LongestIncreasingPathInAMatrix {
 //inspired by this solution: https://discuss.leetcode.com/topic/34835/15ms-concise-java-solution, wrote it myself:
 
-    
     final int dirs[] = new int[]{0, 1, 0, -1, 0};
     
     public int longestIncreasingPath(int[][] matrix) {
