it ain't much, but it's honest work :(

Author: angelgladin

check-completeness-of-a-binary-tree.py

@@ -0,0 +1,22 @@
+# 958. Check Completeness of a Binary Tree
+# https://leetcode.com/problems/check-completeness-of-a-binary-tree/
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def isCompleteTree(self, root: TreeNode) -> bool:
+        q = [root]
+        while q and q[0] is not None:
+            x = q.pop(0)
+            q.append(x.left)
+            q.append(x.right)
+        while q:
+            x = q.pop(0)
+            if x is not None:
+                return False
+        return True

longest-substring-with-at-most-k-distinct-characters.py

@@ -0,0 +1,23 @@
+# 340. Longest Substring with At Most K Distinct Characters
+# https://leetcode.com/problems/longest-substring-with-at-most-k-distinct-characters/
+
+class Solution:
+    def lengthOfLongestSubstringKDistinct(self, s: str, k: int) -> int:
+        from collections import defaultdict
+        
+        w = defaultdict(int)
+        i, j, n, ans = 0, 0, len(s), 0
+        
+        while j < n:
+            w[s[j]] += 1
+            while len(w) > k:
+                c = s[i]
+                if c in w:
+                    w[c] -= 1
+                    if w[c] == 0:
+                        del w[c]
+                i += 1
+            ans = max(ans, j-i+1)
+            j += 1
+        
+        return ans

smallest-subtree-with-all-the-deepest-nodes.py

@@ -0,0 +1,36 @@
+# 865. Smallest Subtree with all the Deepest Nodes
+# https://leetcode.com/problems/smallest-subtree-with-all-the-deepest-nodes/
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def subtreeWithAllDeepest(self, root: TreeNode) -> TreeNode:
+        deepest = (root, 0,)
+        d = dict()
+        s = [(root, 0,)]
+        while s:
+            x_node, x_depth = s.pop()
+            d[x_node.val] = x_depth
+            if x_depth > deepest[1]:
+                deepest = (x_node, x_depth,)
+            if x_node.left:
+                s.append((x_node.left, x_depth+1,))
+            if x_node.right:
+                s.append((x_node.right, x_depth+1,))
+        
+        def ans(node):
+            if node is None or d[node.val] == deepest[1]:
+                return node
+            l, r = ans(node.left), ans(node.right)
+            if l and r:
+                return node
+            elif l and not r:
+                return l
+            return r
+        
+        return ans(root)