2019-07-27

Author: JiayangWu

5028.阿姆斯特朗数/5028-阿姆斯特朗数.py

@@ -0,0 +1,13 @@
+class Solution(object):
+    def isArmstrong(self, N):
+        """
+        :type N: int
+        :rtype: bool
+        """
+        k = len(str(N))
+        n = N
+        s = 0
+        while N:
+            N, tmp = divmod(N, 10)
+            s += tmp ** k
+        return s == n

5034.最大唯一数/5034-最大唯一数.py

@@ -0,0 +1,15 @@
+class Solution(object):
+    def largestUniqueNumber(self, A):
+        """
+        :type A: List[int]
+        :rtype: int
+        """
+        from collections import Counter
+        dic = Counter(A)
+        
+        res = -1
+        for key, val in dic.items():
+            if val == 1:
+                res = max(res, key)
+        return res
+        

5036.最低成本联通所有城市/5036-最低成本联通所有城市.py

@@ -0,0 +1,61 @@
+class UnionFindSet(object):
+    def __init__(self, n):
+ 
+        # m, n = len(grid), len(grid[0])
+        self.roots = [i for i in range(n + 1)]
+        self.rank = [0 for i in range(n + 1)]
+        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 minimumCost(self, N, connections):
+        """
+        :type N: int
+        :type conections: List[List[int]]
+        :rtype: int
+        """
+        from collections import deque
+        from heapq import *
+        ufs = UnionFindSet(N)
+        queue = []
+        
+        for start, end, cost in connections:
+            ufs.union(start, end)
+            queue.append([cost, start, end])
+            
+        if ufs.count != 1:
+            return -1 #无法连接在一起
+        #到这里可以保证一定可以把所有城市连在一起
+        ufs2 = UnionFindSet(N)
+        heapify(queue)       
+        res = 0
+        while ufs2.count > 1:
+            cost, start, end = heappop(queue)
+            if ufs2.find(start) == ufs2.find(end):
+                continue
+            ufs2.union(start, end)
+            res += cost
+        return res
+            
+        

5037.平行课程/5037-平行课程.py

@@ -0,0 +1,36 @@
+class Solution(object):
+    def minimumSemesters(self, N, relations):
+        """
+        :type N: int
+        :type relations: List[List[int]]
+        :rtype: int
+        """
+        indegree = [0 for i in range(N + 1)]
+        adj = [set() for _ in range(N + 1)]
+        for pre, cur in relations:
+            indegree[cur] += 1
+            adj[pre].add(cur)
+            
+        from collections import deque
+        queue = deque()
+        for i, x in enumerate(indegree):
+            if x == 0 and i > 0:
+                queue.append(i)
+        print queue
+        cnt, res = 0, 0
+        out = 0
+        while queue:
+            next_queue = deque()
+            cnt += 1
+            for cur in queue:         
+                out += 1
+                for neighbor in adj[cur]:
+                    indegree[neighbor] -= 1
+
+                    if indegree[neighbor] == 0:
+                        next_queue.append(neighbor)
+            queue = next_queue
+        return cnt if out == N else -1
+        
+            
+