update 300

geemaple · geemaple · commit 01e61d931308 · 2024-06-25T15:23:43.000+08:00
diff --git a/README.md b/README.md
@@ -67,6 +67,7 @@ python problem.py https://www.lintcode.com/problem/92 -l cpp
 ## Binary Search
 | Problem | Solution | Time | Space | Note | Ref |
 | ----- | ----- | ----- | ----- | ----- | ----- |
+| [Leetcode-300. Longest Increasing Subsequence](https://leetcode.com/problems/longest-increasing-subsequence/description/) | [c++](./leetcode/300.longest-increasing-subsequence.cpp), [python](./leetcode/300.longest-increasing-subsequence.py) | O\(N\*logN\) | O\(N\) | \- | - |
 | [Leetcode-3048. Earliest Second To Mark Indices I](https://leetcode.com/problems/earliest-second-to-mark-indices-i/description/) | [c++](./leetcode/3048.earliest-second-to-mark-indices-i.cpp), [python](./leetcode/3048.earliest-second-to-mark-indices-i.py) | O\(M\*logM\) | O\(M\) | \- | - |
 | [Leetcode-2468. Split Message Based On Limit](https://leetcode.com/problems/split-message-based-on-limit/description/) | [c++](./leetcode/2468.split-message-based-on-limit.cpp), [python](./leetcode/2468.split-message-based-on-limit.py) | O\(logN \+ K\) | O\(1\) | Answer \| Bruteforce | - |
 | [Lintcode-437. Copy Books](https://www.lintcode.com/problem/copy-books) | [c++](./lintcode/437.copy-books.cpp), [python](./lintcode/437.copy-books.py) | O\(N\*logP\) | O\(1\) | Answer \| DP | - |
@@ -311,7 +312,6 @@ python problem.py https://www.lintcode.com/problem/92 -l cpp
 | [Leetcode-288. Unique Word Abbreviation](https://leetcode.com/problems/unique-word-abbreviation/description/) | [c++](./leetcode/288.unique-word-abbreviation.cpp), [python](./leetcode/288.unique-word-abbreviation.py) | \- | \- | \- | - |
 | [Leetcode-289. Game Of Life](https://leetcode.com/problems/game-of-life/description/) | [python](./leetcode/289.game-of-life.py) | \- | \- | \- | - |
 | [Leetcode-295. Find Median From Data Stream](https://leetcode.com/problems/find-median-from-data-stream/description/) | [c++](./leetcode/295.find-median-from-data-stream.cpp), [python](./leetcode/295.find-median-from-data-stream.py) | \- | \- | \- | - |
-| [Leetcode-300. Longest Increasing Subsequence](https://leetcode.com/problems/longest-increasing-subsequence/description/) | [c++](./leetcode/300.longest-increasing-subsequence.cpp), [python](./leetcode/300.longest-increasing-subsequence.py) | \- | \- | \- | - |
 | [Leetcode-305. Number Of Islands II](https://leetcode.com/problems/number-of-islands-ii/description/) | [c++](./leetcode/305.number-of-islands-ii.cpp), [python](./leetcode/305.number-of-islands-ii.py) | \- | \- | \- | - |
 | [Leetcode-311. Sparse Matrix Multiplication](https://leetcode.com/problems/sparse-matrix-multiplication/description/) | [c++](./leetcode/311.sparse-matrix-multiplication.cpp), [python](./leetcode/311.sparse-matrix-multiplication.py) | \- | \- | \- | - |
 | [Leetcode-312. Burst Balloons](https://leetcode.com/problems/burst-balloons/description/) | [c++](./leetcode/312.burst-balloons.cpp), [python](./leetcode/312.burst-balloons.py) | \- | \- | \- | - |
@@ -438,5 +438,5 @@ python problem.py https://www.lintcode.com/problem/92 -l cpp
 Total sovled: **320**<br/>
 PS: semicolon(;) after each note means related questions are checked<br/>
 <br/>
-Auto updated at: **2024-06-25 11:34:45**<br/>
+Auto updated at: **2024-06-25 15:23:43**<br/>
 
diff --git a/leetcode/300.longest-increasing-subsequence.cpp b/leetcode/300.longest-increasing-subsequence.cpp
@@ -1,55 +1,70 @@
-// O(N * logN)
-// http://www.geeksforgeeks.org/longest-monotonically-increasing-subsequence-size-n-log-n/
+//  Category: Array, Binary Search, Dynamic Programming
+//  Time: O(N*logN)
+//  Space: O(N)
+//  Ref: -
+//  Note: -
+
+//  Given an integer array nums, return the length of the longest strictly increasing subsequence.
+//   
+//  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
+//  -104 <= nums[i] <= 104
+//  
+//   
+//  Follow up: Can you come up with an algorithm that runs in O(n log(n)) time complexity?
+//  
+
 class Solution {
 public:
     int lengthOfLIS(vector<int>& nums) {
-        vector<int> table;
-        for(auto i = 0; i < nums.size(); ++i)
-        {
-            auto it = lower_bound(table.begin(), table.end(), nums[i]);
-            if (it == table.end())
-            {
-                table.push_back(nums[i]);
-            }
-            else
-            {
-                *it = nums[i];
+        vector<int> res;
+        for (int n : nums) {
+            auto it = lower_bound(res.begin(), res.end(), n);
+            if (it == res.end()) {
+                res.push_back(n);
+            } else {
+                *it = n;
             }
         }
 
-        return table.size();
+        return res.size();
     }
 };
 
-// f(i) = max(1, f(j) + 1 if j < i and nums[j] < nums[i])
-// O(N ^ 2)
-class Solution2 {
+
+class Solution {
 public:
     int lengthOfLIS(vector<int>& nums) {
-        
-        if (nums.size() == 0)
-        {
-            return 0;
-        }
-        
-        int m = nums.size();
-        vector<int> table(m, 0);
-        table[0] = 1;
-        
-        for(auto i = 1; i < m; ++i)
-        {
-            int value =  1;
-            for(auto j = 0; j < i; ++j)
-            {
-                if (nums[j] < nums[i])
-                {
-                    value = max(value, table[j] + 1);
+        int n = nums.size();
+        vector<int> dp(n, 1);
+
+        for (int i = 1; i < n; i++) {
+            for (int j = 0; j < i; j++ ) {
+                if (nums[i] > nums[j]) {
+                    dp[i] = max(dp[i], dp[j] + 1);
                 }
             }
-            table[i] = value;
         }
-        
-        return *max_element(table.begin(), table.end());
+
+        return *max_element(dp.begin(), dp.end());
     }
 };
 
diff --git a/leetcode/300.longest-increasing-subsequence.py b/leetcode/300.longest-increasing-subsequence.py
@@ -1,68 +1,74 @@
-# O(N * logN)
-# https://www.geeksforgeeks.org/longest-monotonically-increasing-subsequence-size-n-log-n/
-class Solution(object):
-    def lengthOfLIS(self, nums):
-        """
-        :type nums: List[int]
-        :rtype: int
-        """
+#  Category: Array, Binary Search, Dynamic Programming
+#  Time: O(N*logN)
+#  Space: O(N)
+#  Ref: -
+#  Note: -
+
+#  Given an integer array nums, return the length of the longest strictly increasing subsequence.
+#   
+#  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
+#  -104 <= nums[i] <= 104
+#  
+#   
+#  Follow up: Can you come up with an algorithm that runs in O(n log(n)) time complexity?
+#  
+
+class Solution:
+    # https://www.geeksforgeeks.org/longest-monotonically-increasing-subsequence-size-n-log-n/
+    def lengthOfLIS(self, nums: List[int]) -> int:
         res = []
         for n in nums:
-            index = self.binary_search(res, n) # use bisect.bisect_left to reduce more runtime
-            if index == -1:
-                res.append(n)
-            else:
+            index = self.lower_bound(res, n)
+            if index < len(res):
                 res[index] = n
+            else:
+                res.append(n)
 
         return len(res)
 
-    def binary_search(self, nums, target):
-        #find element no less than target
-
-        if len(nums) == 0:
-            return -1
 
+    def lower_bound(self, nums: List[int], target: int) -> int:
+        # find the smallest index >= target
         start = 0
-        end = len(nums) - 1
+        end = len(nums)
+
+        while start < end:
+            mid = start + (end - start) // 2
 
-        while(start + 1 < end):
-            mid = start + (end - start) / 2
             if nums[mid] < target:
-                start = mid
+                start = mid + 1
             else:
                 end = mid
 
-        if nums[start] >= target:
-            return start
-
-        if nums[end] >= target:
-            return end
-
-        return -1
-
+        return start
 
-# f(i) = max(1, f(j) + 1 if j < i and nums[j] < nums[i])
-# O(N ^ 2)
-class Solution2(object):
-    def lengthOfLIS(self, nums):
-        """
-        :type nums: List[int]
-        :rtype: int
-        """
-        if nums is None or len(nums) == 0:
-            return 0
-
-        m = len(nums)
-        table = [0 for _ in range(m)]
-        table[0] = 1
-
-        for i in range(1, m):
-            value = 1
+class Solution:
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        n = len(nums)
+        dp = [1 for i in range(n)]
 
+        for i in range(1, n):
             for j in range(i):
-                if nums[j] < nums[i]:
-                    value = max(value, table[j] + 1)
-
-            table[i] = value
+                if nums[i] > nums[j]:
+                    dp[i] = max(dp[i], dp[j] + 1)
 
-        return max(table)
+        return max(dp)
