2020-01-22

Author: JiayangWu

1318.或运算的最小翻转次数/1318-或运算的最小翻转次数.py

@@ -0,0 +1,14 @@
+class Solution(object):
+    def minFlips(self, a, b, c):
+        """
+        :type a: int
+        :type b: int
+        :type c: int
+        :rtype: int
+        """
+        res = 0
+        while a or b or c:
+            if (a & 1 | b & 1) != (c & 1):
+                res += 1 + (a & 1) * (b & 1)
+            a, b, c = a >> 1, b >> 1, c >> 1
+        return res

1319.连通网络的操作次数/1319-连通网络的操作次数.py

@@ -0,0 +1,50 @@
+
+class UnionFindSet(object):
+    def __init__(self, n):
+        self.roots = [i for i in range(n)]
+        self.rank = [0 for i in range(n)]
+        self.count = n
+ 
+    def find(self, member):
+        tmp = []
+        while member != self.roots[member]:
+            tmp.append(member)
+            member = self.roots[member]
+        for root in tmp:
+            self.roots[root] = member
+        return member
+ 
+    def union(self, p, q):
+        parentP = self.find(p)
+        parentQ = self.find(q)
+        if parentP != parentQ:
+            if self.rank[parentP] > self.rank[parentQ]:
+                self.roots[parentQ] = parentP
+            elif self.rank[parentP] < self.rank[parentQ]:
+                self.roots[parentP] = parentQ
+            else:
+                self.roots[parentQ] = parentP
+                self.rank[parentP] -= 1
+            self.count -= 1
+
+
+class Solution(object):
+    def makeConnected(self, n, connections):
+        """
+        :type n: int
+        :type connections: List[List[int]]
+        :rtype: int
+        """
+        if len(connections) < n - 1:
+            return -1
+
+        res = 0
+        ufs = UnionFindSet(n)
+        for s, e in connections:
+            ufs.union(s, e)
+
+        return ufs.count - 1
+            
+            
+                         
+            

1324.竖直打印单词/1324-竖直打印单词.py

@@ -0,0 +1,26 @@
+class Solution(object):
+    def printVertically(self, s):
+        """
+        :type s: str
+        :rtype: List[str]
+        """
+       
+        l = s.split(" ")
+        max_l = max([len(item) for item in l])
+        
+        res = [""] * max_l
+        for i in range(max_l):
+            tmp = ""
+            for j in range(len(l)):
+                if len(l[j]) > i:
+                    tmp += l[j][i]
+                else:
+                    tmp += " "
+            res[i] = tmp.rstrip()
+            
+        return res
+        # l = s.split(" ")
+        # res = []
+        # for item in zip(*l):
+        #     res.append("".join(item))
+        # return res

1325.删除给定值的叶子节点/1325-删除给定值的叶子节点.py

@@ -0,0 +1,68 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def removeLeafNodes(self, root, target):
+        """
+        :type root: TreeNode
+        :type target: int
+        :rtype: TreeNode
+        """
+        if not root:
+            return root
+        root.left = self.removeLeafNodes(root.left, target)
+        root.right = self.removeLeafNodes(root.right, target)
+        if not root.left and not root.right and root.val == target:
+            return None
+        return root        
+        
+#         from collections import defaultdict, deque
+#         if not root:
+#             return root
+#         outdegree = dict()
+#         parent = dict()
+        
+#         # 层序遍历预处理
+#         queue = deque([root])
+#         while queue:
+#             for _ in range(len(queue)):
+#                 cur = queue.popleft()
+#                 outdegree[cur] = 0
+#                 if cur.left:
+#                     outdegree[cur] += 1
+#                     parent[cur.left] = cur
+#                     queue.append(cur.left)
+#                 if cur.right:
+#                     outdegree[cur] += 1
+#                     parent[cur.right] = cur
+#                     queue.append(cur.right)
+                    
+#         queue = deque([])
+#         for key, val in outdegree.items():
+#             if not val and key.val == target:
+#                 queue.append(key)
+        
+#         while queue:
+#             cur = queue.popleft()
+#             if cur not in parent:
+#                 return None
+#             par = parent[cur]
+#             if par.left and par.left == cur:
+#                 par.left = None
+#                 outdegree[par] -= 1
+#             if par.right and par.right == cur:
+#                 par.right = None
+#                 outdegree[par] -= 1
+            
+#             if outdegree[par] == 0 and par.val == target:
+#                 queue.append(par)
+                
+#         return root
+                
+        
+                
+