Added task 300.

src/main/java/g0201_0300/s0300_longest_increasing_subsequence/Solution.java

@@ -0,0 +1,38 @@
+package g0201_0300.s0300_longest_increasing_subsequence;
+
+public class Solution {
+ public int lengthOfLIS(int[] nums) {
+ if (nums == null || nums.length == 0) {
+ return 0;
+ }
+ int[] dp = new int[nums.length + 1];
+ // prefill the dp table
+ for (int i = 1; i < dp.length; i++) {
+ dp[i] = Integer.MAX_VALUE;
+ }
+ int left = 1;
+ int right = 1;
+ for (int curr : nums) {
+ int start = left, end = right;
+ // binary search, find the one that is lower than curr
+ while (start + 1 < end) {
+ int mid = start + (end - start) / 2;
+ if (dp[mid] > curr) {
+ end = mid;
+ } else {
+ start = mid;
+ }
+ }
+ // update our dp table
+ if (dp[start] > curr) {
+ dp[start] = curr;
+ } else if (curr > dp[start] && curr < dp[end]) {
+ dp[end] = curr;
+ } else if (curr > dp[end]) {
+ dp[++end] = curr;
+ right++;
+ }
+ }
+ return right;
+ }
+}

src/main/java/g0201_0300/s0300_longest_increasing_subsequence/readme.md

@@ -0,0 +1,34 @@
+300\. Longest Increasing Subsequence
+
+Medium
+
+Given an integer array `nums`, return the length of the longest strictly increasing subsequence.
+
+A **subsequence** is a sequence that can be derived from an array by deleting some or no elements without changing the order of the remaining elements. For example, `[3,6,2,7]` is a subsequence of the array `[0,3,1,6,2,2,7]`.
+
+**Example 1:**
+
+**Input:** nums = \[10,9,2,5,3,7,101,18\]
+
+**Output:** 4
+
+**Explanation:** The longest increasing subsequence is \[2,3,7,101\], therefore the length is 4. 
+
+**Example 2:**
+
+**Input:** nums = \[0,1,0,3,2,3\]
+
+**Output:** 4 
+
+**Example 3:**
+
+**Input:** nums = \[7,7,7,7,7,7,7\]
+
+**Output:** 1 
+
+**Constraints:**
+
+* `1 <= nums.length <= 2500`
+* <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+
+**Follow up:** Can you come up with an algorithm that runs in `O(n log(n))` time complexity?

src/test/java/g0201_0300/s0300_longest_increasing_subsequence/SolutionTest.java

@@ -0,0 +1,23 @@
+package g0201_0300.s0300_longest_increasing_subsequence;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.Test;
+
+public class SolutionTest {
+ @Test
+ public void lengthOfLIS() {
+ assertThat(new Solution().lengthOfLIS(new int[] {10, 9, 2, 5, 3, 7, 101, 18}), equalTo(4));
+ }
+
+ @Test
+ public void lengthOfLIS2() {
+ assertThat(new Solution().lengthOfLIS(new int[] {0, 1, 0, 3, 2, 3}), equalTo(4));
+ }
+
+ @Test
+ public void lengthOfLIS3() {
+ assertThat(new Solution().lengthOfLIS(new int[] {7, 7, 7, 7, 7, 7, 7}), equalTo(1));
+ }
+}