update

Author: ncdhz

code/124.二叉树中的最大路径和.py

@@ -0,0 +1,37 @@
+#
+# @lc app=leetcode.cn id=124 lang=python3
+#
+# [124] 二叉树中的最大路径和
+#
+
+
+# @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 maxPathSum(self, root: Optional[TreeNode]) -> int:
+ result = -2000
+ 
+ def _maxPathSum(root):
+ nonlocal result
+ 
+ if root is None:
+ return 0
+ 
+ left = max([_maxPathSum(root.left), 0])
+ right = max([_maxPathSum(root.right), 0])
+ val = root.val
+
+ result = max([val + left + right, result])
+
+ return max([val, val + left, val + right])
+ 
+ _maxPathSum(root)
+ return result
+
+# @lc code=end

code/264.丑数-ii.py

@@ -0,0 +1,24 @@
+#
+# @lc app=leetcode.cn id=264 lang=python3
+#
+# [264] 丑数 II
+#
+import heapq
+# @lc code=start
+class Solution:
+ def nthUglyNumber(self, n: int) -> int:
+
+ nums = [1]
+ eliminate = set()
+ for _ in range(n - 1):
+ curr = heapq.heappop(nums)
+ 
+ for i in [2, 3, 5]:
+ n = curr * i
+ if n not in eliminate:
+ heapq.heappush(nums, n)
+ eliminate.add(n)
+
+ return heapq.heappop(nums)
+# @lc code=end
+

code/313.超级丑数.py

@@ -0,0 +1,24 @@
+#
+# @lc app=leetcode.cn id=313 lang=python3
+#
+# [313] 超级丑数
+#
+
+import heapq
+# @lc code=start
+class Solution:
+ def nthSuperUglyNumber(self, n: int, primes: List[int]) -> int:
+ nums = [1]
+ en = set()
+ for _ in range(n - 1):
+ n = heapq.heappop(nums)
+
+ for p in primes:
+ a = n * p
+ if a not in en:
+ en.add(a)
+ heapq.heappush(nums, a)
+ 
+ return heapq.heappop(nums) 
+# @lc code=end
+

code/318.最大单词长度乘积.py

@@ -0,0 +1,24 @@
+#
+# @lc app=leetcode.cn id=318 lang=python3
+#
+# [318] 最大单词长度乘积
+#
+
+# @lc code=start
+class Solution:
+ def maxProduct(self, words: List[str]) -> int:
+ max_ = 0
+ words = sorted(words, key=lambda k: len(k), reverse=True)
+ wlen = len(words)
+ for i in range(wlen):
+ w1 = words[i]
+ w1l = len(w1)
+ w1s = set(w1)
+ for j in range(i + 1, wlen):
+ w2 = words[j]
+ w2s = set(w2)
+ if len(w1s | w2s) == (len(w1s) + len(w2s)):
+ max_ = max([w1l * len(w2), max_])
+ break
+ return max_
+# @lc code=end

code/319.灯泡开关.py

@@ -0,0 +1,11 @@
+#
+# @lc app=leetcode.cn id=319 lang=python3
+#
+# [319] 灯泡开关
+#
+import math
+# @lc code=start
+class Solution:
+ def bulbSwitch(self, n: int) -> int:
+ return int(math.sqrt(n))
+# @lc code=end

code/324.摆动排序-ii.py

@@ -0,0 +1,23 @@
+#
+# @lc app=leetcode.cn id=324 lang=python3
+#
+# [324] 摆动排序 II
+#
+
+# @lc code=start
+class Solution:
+ def wiggleSort(self, nums: List[int]) -> None:
+ """
+ Do not return anything, modify nums in-place instead.
+ """
+ arrs = sorted(nums)
+ j = 1
+ al = len(arrs)
+ al2 = (len(arrs) + 1) // 2
+ for i in range(0, al, 2):
+ nums[i] = arrs[al2 - j]
+ if i + 1 < al:
+ nums[i + 1] = arrs[al - j]
+ j += 1
+# @lc code=end
+

code/328.奇偶链表.py

@@ -0,0 +1,37 @@
+#
+# @lc app=leetcode.cn id=328 lang=python3
+#
+# [328] 奇偶链表
+#
+
+# @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 oddEvenList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+ if head is None:
+ return head
+ 
+ root = head
+ r2s = None
+ r2 = None
+
+ while root is not None and root.next is not None:
+ if r2 is None:
+ r2 = root.next
+ r2s = root.next
+ else:
+ r2.next = root.next
+ r2 = r2.next
+ root.next = root.next.next
+ if root.next is None:
+ break
+ root = root.next
+ if r2 is not None:
+ r2.next = None
+ root.next = r2s
+ return head
+# @lc code=end

code/700.二叉搜索树中的搜索.py

@@ -0,0 +1,24 @@
+#
+# @lc app=leetcode.cn id=700 lang=python3
+#
+# [700] 二叉搜索树中的搜索
+#
+
+# @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 searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
+ if root is None:
+ return None
+ if val == root.val:
+ return root
+ elif val > root.val:
+ return self.searchBST(root.right, val)
+ return self.searchBST(root.left, val)
+# @lc code=end
+

code/703.数据流中的第-k-大元素.py

@@ -0,0 +1,52 @@
+#
+# @lc app=leetcode.cn id=703 lang=python3
+#
+# [703] 数据流中的第 K 大元素
+#
+
+# @lc code=start
+class KthLargest:
+
+ def __init__(self, k: int, nums: List[int]):
+ self.k = k
+ self.nums = sorted(nums, reverse=True)[:k]
+
+ def find_val(self, val):
+ s = 0
+ e = len(self.nums)
+ while s < e:
+ mid = (s + e) // 2
+ n = self.nums[mid]
+ if n == val:
+ return mid
+ elif n < val:
+ e = mid - 1
+ else:
+ s = mid + 1
+ return s
+
+ def add(self, val: int) -> int:
+ 
+ if len(self.nums) >= self.k:
+ n = self.nums[self.k - 1]
+ if n > val:
+ return n
+ 
+ i = self.find_val(val)
+ 
+ if len(self.nums) > i:
+ v = self.nums[i]
+ if v > val:
+ i += 1
+ self.nums = self.nums[:i] + [val] + self.nums[i:]
+ self.nums = self.nums[:self.k]
+ else:
+ self.nums.append(val)
+
+ return self.nums[self.k - 1]
+
+# Your KthLargest object will be instantiated and called as such:
+# obj = KthLargest(k, nums)
+# param_1 = obj.add(val)
+# @lc code=end
+

code/704.二分查找.py

@@ -0,0 +1,24 @@
+#
+# @lc app=leetcode.cn id=704 lang=python3
+#
+# [704] 二分查找
+#
+
+# @lc code=start
+class Solution:
+ def search(self, nums: List[int], target: int) -> int:
+ s = 0
+ e = len(nums)
+ while s < e:
+ mid = (s + e) // 2
+ if nums[mid] == target:
+ return mid
+ elif nums[mid] > target:
+ e = mid - 1
+ else:
+ s = mid + 1
+ if len(nums) > s and nums[s] == target:
+ return s
+ return -1
+# @lc code=end
+