[N-0] refactor 300

Author: fishercoder1534

src/main/java/com/fishercoder/solutions/_300.java

@@ -13,52 +13,47 @@
 
  Your algorithm should run in O(n2) complexity.
 
- Follow up: Could you improve it to O(n log n) time complexity?
+ Follow up: Could you improve it to O(nlogn) time complexity?
  */
 public class _300 {
 
-    /**
-     * credit: https://discuss.leetcode.com/topic/28719/short-java-solution-using-dp-o-n-log-n
-     *
-     * The idea is that as you iterate the sequence,
-     * you keep track of the minimum value a subsequence of given length might end with,
-     * for all so far possible subsequence lengths.
-     *
-     * So dp[i] is the minimum value a subsequence of length i+1 might end with.
-     * Having this info, for each new number we iterate to,
-     * we can determine the longest subsequence where it can be appended using binary search.
-     * The final answer is the length of the longest subsequence we found so far.*/
-    public int lengthOfLIS(int[] nums) {
-        int[] dp = new int[nums.length];
-        int len = 0;
-        for (int x : nums) {
-            /**Java Doc of this binarySearch API:
-             * @return index of the search key, if it is contained in the array
-             *         within the specified range;
-             *         otherwise, <tt>(-(<i>insertion point</i>) - 1)</tt>.  The
-             *         <i>insertion point</i> is defined as the point at which the
-             *         key would be inserted into the array: the index of the first
-             *         element in the range greater than the key,
-             *         or <tt>toIndex</tt> if all
-             *         elements in the range are less than the specified key.  Note
-             *         that this guarantees that the return value will be &gt;= 0 if
-             *         and only if the key is found.*/
-            int index = Arrays.binarySearch(dp, 0, len, x);
-            if (index < 0) {
-                index = -(index + 1);
-            }
-            dp[index] = x;
-            if (index == len) {
-                len++;
+    public static class Solution1 {
+
+        /**
+         * credit: https://discuss.leetcode.com/topic/28719/short-java-solution-using-dp-o-n-log-n
+         * The idea is that as you iterate the sequence,
+         * you keep track of the minimum value a subsequence of given length might end with,
+         * for all so far possible subsequence lengths.
+         * So dp[i] is the minimum value a subsequence of length i+1 might end with.
+         * Having this info, for each new number we iterate to,
+         * we can determine the longest subsequence where it can be appended using binary search.
+         * The final answer is the length of the longest subsequence we found so far.
+         */
+        public int lengthOfLIS(int[] nums) {
+            int[] dp = new int[nums.length];
+            int len = 0;
+            for (int x : nums) {
+                /**Java Doc of this binarySearch API:
+                 * @return index of the search key, if it is contained in the array
+                 *         within the specified range;
+                 *         otherwise, <tt>(-(<i>insertion point</i>) - 1)</tt>.  The
+                 *         <i>insertion point</i> is defined as the point at which the
+                 *         key would be inserted into the array: the index of the first
+                 *         element in the range greater than the key,
+                 *         or <tt>toIndex</tt> if all
+                 *         elements in the range are less than the specified key.  Note
+                 *         that this guarantees that the return value will be &gt;= 0 if
+                 *         and only if the key is found.*/
+                int index = Arrays.binarySearch(dp, 0, len, x);
+                if (index < 0) {
+                    index = -(index + 1);
+                }
+                dp[index] = x;
+                if (index == len) {
+                    len++;
+                }
             }
+            return len;
         }
-        return len;
     }
-
-    public static void main(String... args) {
-        _300 test = new _300();
-        int[] nums = new int[]{10, 9, 2, 5, 3, 7, 101, 18};
-        System.out.println(test.lengthOfLIS(nums));
-    }
-
 }

src/test/java/com/fishercoder/_300Test.java

@@ -0,0 +1,26 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._300;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static junit.framework.Assert.assertEquals;
+
+public class _300Test {
+
+    private static _300.Solution1 solution1;
+    private static int[] nums;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _300.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        nums = new int[]{10, 9, 2, 5, 3, 7, 101, 18};
+        assertEquals(4, solution1.lengthOfLIS(nums));
+
+    }
+
+}