@@ -0,0 +1,19 @@
+class Solution:
+def findMaxConsecutiveOnes(self, nums: List[int]) -> int:
+maxConZeros = 0
+left = 0
+flips = 1
+zeros = 0
+
+for right in range(len(nums)):
+if nums[right] == 0:
+zeros += 1
+
+while zeros > flips:
+if nums[left] == 0:
+zeros -= 1
+left += 1
+
+maxConZeros = max(right - left + 1, maxConZeros)
+
+return maxConZeros

@@ -1,16 +1,22 @@
+from collections import deque
+
 class Solution:
-def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+def connect(self, root: 'Node') -> 'Node':
 if not root: return None
-if root.val == p.val or root.val == q.val:
-return root
 
-left = self.lowestCommonAncestor(root.left, p, q)
-right = self.lowestCommonAncestor(root.right, p, q)
+q = deque()
+q.append(root)
 
-if left and right:
-return root
+while q:
+level = []
+for _ in range(len(q)):
+node = q.popleft()
+level.append(node)
+if node.left:
+q.append(node.left)
+if node.right:
+q.append(node.right)
+for i in range(len(level) - 1):
+level[i].next = level[i+1]
 
-if not left and not right:
-return None
-
-return left or right
+return root

@@ -0,0 +1,16 @@
+class Solution:
+def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+if not root: return None
+if root.val == p.val or root.val == q.val:
+return root
+
+left = self.lowestCommonAncestor(root.left, p, q)
+right = self.lowestCommonAncestor(root.right, p, q)
+
+if left and right:
+return root
+
+if not left and not right:
+return None
+
+return left or right

@@ -0,0 +1,27 @@
+class Solution:
+def countUnivalSubtrees(self, root: TreeNode) -> int:
+self.count = 0
+self.dfs(root)
+return self.count
+
+def dfs(self, node):
+if not node:
+return
+
+if self.isUniVal(node, node.val):
+self.count += 1
+
+self.dfs(node.left)
+self.dfs(node.right)
+
+def isUniVal(self, node, val):
+if node is None: return True
+
+if (node.left is None and
+node.right is None and
+node.val == val):
+return True
+
+return (node.val == val and
+self.isUniVal(node.left, val) and
+self.isUniVal(node.right, val))

@@ -0,0 +1,48 @@
+from collections import deque
+
+class TreeNode(object):
+def __init__(self, x):
+self.val = x
+self.left = None
+self.right = None
+
+class Codec:
+
+def serialize(self, root):
+"""Encodes a tree to a single string.
+
+:type root: TreeNode
+:rtype: str
+"""
+if root is None: return "X,"
+
+left = self.serialize(root.left)
+right = self.serialize(root.right)
+
+return str(root.val) + "," + left + right
+
+
+def deserialize(self, data):
+"""Decodes your encoded data to tree.
+
+:type data: str
+:rtype: TreeNode
+"""
+data = data.split(",")[0:-1]
+nodes_left = deque()
+for val in data:
+nodes_left.append(val)
+
+def helper(nodes):
+val = nodes.popleft()
+
+if val == "X":
+return None
+
+node = TreeNode(int(val))
+node.left = helper(nodes)
+node.right = helper(nodes)
+
+return node
+
+return helper(nodes_left)