[서폿] 2021.10.03

keeprainy/leetcode/128_Longest_Consecutive_Sequence.py

@@ -0,0 +1,34 @@
+"""
+#  LeetCode
+#  ver.Python3
+#
+#  Created by GGlifer
+#
+#  Open Source
+"""
+
+import heapq
+from typing import *
+
+
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        # Set is implemented in hashset at Python3
+        s = set(nums)
+
+        max_len = 0
+        for e in s:
+            if e-1 in s:  # Check e is first element in sequence
+                continue
+            else:
+                tmp_len = 0
+                while e in s:
+                    tmp_len += 1
+                    e += 1
+                max_len = max(max_len, tmp_len)
+
+        return max_len
+
+
+if __name__ == '__main__':
+    solution = Solution()

keeprainy/leetcode/20_Valid_Parentheses.py

@@ -0,0 +1,35 @@
+"""
+#  LeetCode
+#  ver.Python3
+#
+#  Created by GGlifer
+#
+#  Open Source
+"""
+
+from typing import *
+
+
+class Solution:
+    def isValid(self, s: str) -> bool:
+        # Square bracket []
+        # Curly bracket {}
+        # Parentheses ()
+        pair = {')': '(', '}': '{', ']': '['}
+
+        st = []  # stack
+
+        for b in s:
+            if b in ['(', '{', '[']:
+                st.append(b)
+            else:
+                if not st or st[-1] != pair[b]:
+                    return False
+                st.pop()
+
+        return len(st) == 0
+
+
+if __name__ == '__main__':
+    solution = Solution()
+

keeprainy/leetcode/39_Combination_Sum.py

@@ -0,0 +1,36 @@
+"""
+#  LeetCode
+#  ver.Python3
+#
+#  Created by GGlifer
+#
+#  Open Source
+"""
+
+from typing import *
+
+
+class Solution:
+    def combinationSum4(self, nums: List[int], target: int) -> int:
+        # 1 <= target <= 1000
+        # DP about target
+        dp = [0 for _ in range(target+1)]
+        for num in nums:
+            if num <= target:
+                dp[num] += 1
+
+        for i in range(2, target+1):
+            for num in nums:
+                if i-num >= 1:
+                    dp[i] += dp[i-num]
+
+        return dp[target]
+
+
+if __name__ == '__main__':
+    solution = Solution()
+
+    nums = [4, 2, 1]
+    target = 32
+
+    print(solution.combinationSum4(nums, target))

keeprainy/leetcode/55_Jump_Game.py

@@ -0,0 +1,40 @@
+"""
+#  LeetCode
+#  ver.Python3
+#
+#  Created by GGlifer
+#
+#  Open Source
+"""
+
+from typing import *
+from collections import deque
+from itertools import accumulate
+
+
+class Solution:
+    def canJump(self, nums: List[int]) -> bool:
+        if len(nums) == 1:
+            return True
+
+        # i+nums[i] -> max idx with index i can reach
+        # dp[i] -> max idx with index 0~i can reach
+        dp = [i+nums[i] for i in range(len(nums))]
+        for i in range(1, len(nums)):
+            dp[i] = max(dp[i], dp[i-1])
+
+        # Jump!!!
+        idx = 0
+        while idx < len(nums) and idx < dp[idx]:
+            idx = dp[idx]
+
+        # Check max idx with can reach is more than last idx
+        return bool(idx >= len(nums)-1)
+
+
+if __name__ == '__main__':
+    solution = Solution()
+
+    nums = [3, 2, 1, 0, 4]
+
+    solution.canJump(nums)

keeprainy/main.py

@@ -0,0 +1,35 @@
+"""
+#  LeetCode
+#  ver.Python3
+#
+#  Created by GGlifer
+#
+#  Open Source
+"""
+
+from typing import *
+
+
+class Solution:
+    def combinationSum4(self, nums: List[int], target: int) -> int:
+
+        dp = [0 for _ in range(target+1)]
+        for num in nums:
+            if num <= target:
+                dp[num] += 1
+
+        for i in range(2, target+1):
+            for num in nums:
+                if i-num >= 1:
+                    dp[i] += dp[i-num]
+
+        return dp[target]
+
+
+if __name__ == '__main__':
+    solution = Solution()
+
+    nums = [4, 2, 1]
+    target = 32
+
+    print(solution.combinationSum4(nums, target))