Merge pull request DaleStudy#189 from leokim0922/main

[Leo] 12th Week solutions

Author: leokim0922

jump-game/Leo.py

@@ -0,0 +1,18 @@
+class Solution:
+    def canJump(self, nums: List[int]) -> bool:
+        target = len(nums) - 1
+
+        for i in range(target, -1, -1):
+            if i + nums[i] >= target:
+                target = i
+
+        return True if target == 0 else False
+
+        # maxReach = 0
+        # for i, jump in enumerate(nums):
+        #     if i > maxReach:
+        #         return False
+        #     maxReach = max(maxReach, i + jump)
+        # return True
+
+        ## Both TC: O(n), SC: O(1)

longest-common-subsequence/Leo.py

@@ -0,0 +1,15 @@
+class Solution:
+    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
+        dp = [0] * (len(text2) + 1)
+
+        for i in range(len(text1)):
+            prev_row = dp[:]
+            for j in range(len(text2)):
+                if text1[i] == text2[j]:
+                    dp[j + 1] = prev_row[j] + 1
+                else:
+                    dp[j + 1] = max(dp[j], prev_row[j + 1])
+
+        return dp[-1]
+
+        ## TC: O(mn), SC: O(n)

longest-increasing-subsequence/Leo.py

@@ -0,0 +1,28 @@
+class Solution:
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        arr = [nums.pop(0)]
+
+        for n in nums:
+            if n > arr[-1]:
+                arr.append(n)
+            else:
+                arr[bisect_left(arr, n)] = n
+
+        return len(arr)
+
+        ## TC: O(nlogn) SC: O(n)
+
+        # if not nums:
+        #     return 0
+
+        # n = len(nums)
+        # LIS = [1] * n
+
+        # for i in range(1, n):
+        #     for j in range(i):
+        #         if nums[i] > nums[j]:
+        #             LIS[i] = max(LIS[i], 1 + LIS[j])
+
+        # return max(LIS)
+
+        ## DP solution: TC: O(n^2) O(n)

maximum-subarray/Leo.py

@@ -0,0 +1,16 @@
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+
+        maxSub = nums[0]
+        curSum = 0
+
+        for n in nums:
+            if curSum < 0:
+                curSum = 0
+
+            curSum += n
+            maxSub = max(curSum, maxSub)
+
+        return maxSub
+
+        ## TC: O(n), SC: O(1)

unique-paths/Leo.py

@@ -0,0 +1,13 @@
+class Solution:
+    def uniquePaths(self, m: int, n: int) -> int:
+        dp = [1] * n
+
+        for _ in range(1, m):
+            for i in range(1, n):
+                dp[i] += dp[i - 1]
+
+        return dp[-1]
+        ## TC: O(mn), SC: O(n)
+
+        ## return math.comb(m + n - 2, m - 1)
+        ## TC: O(1) whatever constant, SC: O(1)