update code files

Author: ProHiryu

code/1004.max-consecutive-ones-iii.py

@@ -0,0 +1,24 @@
+#
+# @lc app=leetcode id=1004 lang=python3
+#
+# [1004] Max Consecutive Ones III
+#
+
+# @lc code=start
+class Solution:
+    def longestOnes(self, A: List[int], K: int) -> int:
+        res = 0
+        l = 0
+        for r in range(len(A)):
+            if K >= 0:
+                res = max(res, r - l)
+            if A[r]: continue
+            K -= 1
+            while K < 0:
+                while A[l]: l += 1
+                K += 1
+                l += 1
+        if K >= 0: res = max(res, r - l + 1)
+        return res
+# @lc code=end
+

code/1013.partition-array-into-three-parts-with-equal-sum.py

@@ -0,0 +1,12 @@
+#
+# @lc app=leetcode id=1013 lang=python3
+#
+# [1013] Partition Array Into Three Parts With Equal Sum
+#
+
+# @lc code=start
+class Solution:
+    def canThreePartsEqualSum(self, A: List[int]) -> bool:
+        
+# @lc code=end
+

code/1049.last-stone-weight-ii.py

@@ -0,0 +1,23 @@
+#
+# @lc app=leetcode id=1049 lang=python3
+#
+# [1049] Last Stone Weight II
+#
+
+# @lc code=start
+class Solution:
+    '''
+    dp[stone + i] = max(dp[stone + i], dp[i] + stone)
+    '''
+    def lastStoneWeightII(self, stones: List[int]) -> int:
+        s = sum(stones)
+        m = s // 2
+
+        dp = [0 for _ in range(m + 1)]
+        for stone in stones:
+            for i in range(m + 1, -1, -1):
+                if stone + i <= m:
+                    dp[stone + i] = max(dp[stone + i], dp[i] + stone)
+        return s - 2*(dp[-1])
+# @lc code=end
+

code/105.construct-binary-tree-from-preorder-and-inorder-traversal.py

@@ -0,0 +1,26 @@
+#
+# @lc app=leetcode id=105 lang=python3
+#
+# [105] Construct Binary Tree from Preorder and Inorder Traversal
+#
+
+# @lc code=start
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
+        def build_tree(pre, i):
+            if not pre:
+                return None
+            node = TreeNode(pre[0])
+            index = i.index(pre[0])
+            node.left = build_tree(pre[1:1+index], i[:index])
+            node.right = build_tree(pre[1+index:], i[index+1:])
+            return node
+        return build_tree(preorder, inorder)
+# @lc code=end
+

code/106.construct-binary-tree-from-inorder-and-postorder-traversal.py

@@ -0,0 +1,26 @@
+#
+# @lc app=leetcode id=106 lang=python3
+#
+# [106] Construct Binary Tree from Inorder and Postorder Traversal
+#
+
+# @lc code=start
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
+        def build_tree(i, post):
+            if not post:
+                return None
+            node = TreeNode(post[-1])
+            index = i.index(post[-1])
+            node.left = build_tree(i[:index], post[:index])
+            node.right = build_tree(i[index + 1:], post[index:-1])
+            return node
+        return build_tree(inorder, postorder)
+# @lc code=end
+

code/1143.longest-common-subsequence.py

@@ -0,0 +1,20 @@
+#
+# @lc app=leetcode id=1143 lang=python3
+#
+# [1143] Longest Common Subsequence
+#
+
+# @lc code=start
+class Solution:
+    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
+        m, n = len(text1), len(text2)
+        dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
+        for i in range(1, m + 1):
+            for j in range(1, n + 1):
+                if text1[i - 1] == text2[j - 1]:
+                    dp[i][j] = dp[i - 1][j - 1] + 1
+                else:
+                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
+        return dp[m][n] 
+# @lc code=end
+

code/120.triangle.py

@@ -0,0 +1,22 @@
+#
+# @lc app=leetcode id=120 lang=python3
+#
+# [120] Triangle
+#
+
+# @lc code=start
+class Solution:
+    def minimumTotal(self, triangle: List[List[int]]) -> int:
+        return self.dp(triangle, 0, len(triangle) - 1)[0]
+        
+    def dp(self, triangle, depth, m):
+        if depth == m:
+            return triangle[depth]
+        last = self.dp(triangle, depth + 1, m)
+        res = []
+        for i, n in enumerate(triangle[depth]):
+            res.append(n + min(last[i], last[i + 1]))
+        return res
+
+# @lc code=end
+

code/1234.replace-the-substring-for-balanced-string.py

@@ -0,0 +1,21 @@
+#
+# @lc app=leetcode id=1234 lang=python3
+#
+# [1234] Replace the Substring for Balanced String
+#
+
+# @lc code=start
+class Solution:
+    def balancedString(self, s: str) -> int:
+        cnt = collections.Counter(s)
+        res = n = len(s)
+        l = 0
+        for r, c in enumerate(s):
+            cnt[c] -= 1
+            while l < n and all(n//4 >= cnt[c] for c in 'QWER'):
+                res = min(r - l + 1, res)
+                cnt[s[l]] += 1
+                l += 1
+        return res
+# @lc code=end
+

code/1248.count-number-of-nice-subarrays.py

@@ -0,0 +1,22 @@
+#
+# @lc app=leetcode id=1248 lang=python3
+#
+# [1248] Count Number of Nice Subarrays
+#
+
+# @lc code=start
+class Solution:
+    def numberOfSubarrays(self, nums: List[int], k: int) -> int:
+        def Most(k):
+            res = 0
+            l = 0
+            for r in range(len(nums)):
+                k -= nums[r] % 2
+                while k < 0:
+                    k += nums[l] % 2
+                    l += 1
+                res += r - l + 1
+            return res
+        return Most(k) - Most(k - 1)
+# @lc code=end
+

code/128.longest-consecutive-sequence.py

@@ -0,0 +1,12 @@
+#
+# @lc app=leetcode id=128 lang=python3
+#
+# [128] Longest Consecutive Sequence
+#
+
+# @lc code=start
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        
+# @lc code=end
+

code/141.linked-list-cycle.py

@@ -0,0 +1,29 @@
+#
+# @lc app=leetcode id=141 lang=python3
+#
+# [141] Linked List Cycle
+#
+
+# @lc code=start
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def hasCycle(self, head: ListNode) -> bool:
+        if not head:
+            return False
+        fast, slow = head, head
+        while fast.next and fast.next.next:
+            fast = fast.next.next
+            slow = slow.next
+            if fast == slow:
+                return True
+        if fast != slow:
+            return False
+        
+        
+# @lc code=end
+

code/142.linked-list-cycle-ii.py

@@ -0,0 +1,28 @@
+#
+# @lc app=leetcode id=142 lang=python3
+#
+# [142] Linked List Cycle II
+#
+
+# @lc code=start
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def detectCycle(self, head: ListNode) -> ListNode:
+        slow, fast = head, head
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+            if slow == fast:
+                slow2 = head
+                while slow != slow2:
+                    slow = slow.next
+                    slow2 = slow2.next
+                return slow
+        return None
+# @lc code=end
+

code/15.3-sum.py

@@ -0,0 +1,32 @@
+#
+# @lc app=leetcode id=15 lang=python3
+#
+# [15] 3Sum
+#
+
+# @lc code=start
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+        res = []
+        i = 0
+        for i in range(len(nums)):
+            if i != 0 and nums[i] == nums[i - 1]:
+                continue
+            l, r = i + 1, len(nums) - 1
+            while l < r:
+                if nums[l] + nums[r] == - nums[i]:
+                    res.append([nums[i], nums[l], nums[r]])
+                    l += 1
+                    r -= 1
+                    while l < r and nums[l - 1] == nums[l]:
+                        l += 1
+                    while l < r and nums[r + 1] == nums[r]:
+                        r -= 1
+                elif nums[l] + nums[r] > - nums[i]:
+                    r -= 1
+                else:
+                    l += 1
+        return res
+# @lc code=end
+

code/153.find-minimum-in-rotated-sorted-array.py

@@ -0,0 +1,22 @@
+#
+# @lc app=leetcode id=153 lang=python3
+#
+# [153] Find Minimum in Rotated Sorted Array
+#
+
+# @lc code=start
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        if not nums:
+            return -1
+        l, r = 0, len(nums) - 1
+        res = float("inf")
+        while l < r:
+            m = (r - l) // 2 + l
+            if nums[m] > nums[-1]:
+                l = m + 1
+            else:
+                r = m
+        return nums[l]
+# @lc code=end
+

code/160.intersection-of-two-linked-lists.py

@@ -0,0 +1,24 @@
+#
+# @lc app=leetcode id=160 lang=python3
+#
+# [160] Intersection of Two Linked Lists
+#
+
+# @lc code=start
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
+        if not headB or not headA:
+            return None
+        A, B = headA, headB
+        while A != B:
+            A = A.next if A else headB
+            B = B.next if B else headA
+        return A
+# @lc code=end
+

code/206.reverse-linked-list.py

@@ -0,0 +1,23 @@
+#
+# @lc app=leetcode id=206 lang=python3
+#
+# [206] Reverse Linked List
+#
+
+# @lc code=start
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def reverseList(self, head: ListNode) -> ListNode:
+        pre = None
+        while head:
+            cur = head
+            head = head.next
+            cur.next = pre
+            pre = cur
+        return pre
+# @lc code=end
+