no message

Author: wuduhren

problems/most-stones-removed-with-same-row-or-column.py

@@ -0,0 +1,49 @@
+"""
+Max stones can be remove = number of stones - number of groups
+The stone in the same group has the same row or col with any stone in the group.
+Since finding stones in the same group will take O(N^2)
+Instead, we union the row or col itself.
+
+So initially each col (c1, c2...) and row (r1, r2...)'s parent is itself.
+We iterate through the stones and union the col and row.
+For example, the stone (1, 2) will union r2 and c1.
+the stone (0, 3) will union r3 and c0.
+...
+
+This way, we can also get the number of groups.
+
+See better explanation in https://www.youtube.com/watch?v=beOCN7G4h-M
+
+Time: O(N).
+Space: O(N)
+"""
+class Solution(object):
+    def removeStones(self, stones):
+        def union(x, y):
+            row = 'r'+str(x)
+            col = 'c'+str(y)
+            p1 = find(row)
+            p2 = find(col)
+            if p1==p2: return False
+            parents[p2] = p1
+            return True
+        
+        def find(c):
+            p = parents[c]
+            while p!=parents[p]:
+                p = find(p)
+            parents[c] = p
+            return p
+        
+        parents = {}
+        for x, y in stones:
+            row = 'r'+str(x)
+            col = 'c'+str(y)
+            parents[row] = row
+            parents[col] = col
+        
+        groupCount = len(parents)
+        for x, y in stones:
+            if union(x, y): groupCount -= 1
+        
+        return len(stones)-groupCount

problems/network-delay-time.py

@@ -78,3 +78,52 @@ def networkDelayTime(self, times, N, K):
 
         return -1
 
+
+
+
+
+
+
+class Solution(object):
+    def networkDelayTime(self, times, n, k):
+        G = collections.defaultdict(list) #adjacency list
+        D = [float('inf')]*(n+1) #D[n] store the distance between n and k
+        D[k] = 0
+        h = [(0, k)]
+        visited = set()
+        
+        #form the djacency list
+        for u, v, w in times:
+            G[u].append((v, w))
+        
+        #dijkstra
+        while h:
+            d1, node = heapq.heappop(h)
+            if node in visited: continue
+            visited.add(node)
+            
+            for nei, d2 in G[node]:
+                if d1+d2<D[nei]:
+                    D[nei] = d1+d2
+                    heapq.heappush(h, (D[nei], nei))
+        
+        #iterate through the distance between n and k, find ans
+        ans = float('-inf')
+        for i, d in enumerate(D):
+            if i==0: continue
+            if d==float('inf'): return -1
+            ans = max(ans, d)
+        return ans
+            
+            
+        
+
+
+
+
+
+
+
+
+
+

problems/number-of-connected-components-in-an-undirected-graph.py

@@ -20,9 +20,31 @@ def dfs(start):
             g[n2].append(n1)
 
         for n in xrange(N):
-            # print visited
             if n in visited: continue
             dfs(n)
             count += 1
 
+        return count
+
+
+class Solution(object):
+    def countComponents(self, n, edges):
+        def find(n):
+            p = parents[n]
+            while p!=parents[p]:
+                p = find(p)
+            parents[n] = p
+            return p
+        
+        def union(n1, n2):
+            p1, p2 = find(n1), find(n2)
+            if p1==p2: return False
+            parents[p2] = p1
+            return True
+        
+        count = n
+        parents = [n for n in xrange(n)]
+        
+        for n1, n2 in edges:
+            if union(n1, n2): count -= 1
         return count

problems/number-of-islands-ii.py

@@ -0,0 +1,50 @@
+"""
+For each new land, the count will -= ((number of neighbors) - 1).
+Because some for this new land introduced, some of the separate islands will be connected.
+Note that, "number of neighbors", islands connected does not count. So for each neighbor, we use "find" to find its root.
+"""
+class Solution(object):
+    def numIslands2(self, M, N, positions):
+        def coorToNum(r, c):
+            return N*r+c
+        
+        def find(n):
+            p = parents[n]
+            while p!=parents[p]:
+                p = find(p)
+            parents[n] = p
+            return parents[n]
+            
+        def union(n1, n2):
+            p1 = find(n1)
+            p2 = find(n2)
+            
+            if p1==p2: return
+            parents[p1] = p2
+            
+        count = 0
+        lands = set()
+        ans = []
+        parents = [n for n in xrange(M*N)]
+        
+        for r, c in positions:
+            n = coorToNum(r, c)
+            
+            if n in lands:
+                ans.append(count)
+                continue
+            
+            neis = set()
+            if r+1<M and coorToNum(r+1, c) in lands: neis.add(find(coorToNum(r+1, c)))
+            if 0<=r-1 and coorToNum(r-1, c) in lands: neis.add(find(coorToNum(r-1, c)))
+            if c+1<N and coorToNum(r, c+1) in lands: neis.add(find(coorToNum(r, c+1)))
+            if 0<=c-1 and coorToNum(r, c-1) in lands: neis.add(find(coorToNum(r, c-1)))
+                
+            count -= (len(neis)-1)
+            lands.add(n)
+            ans.append(count)
+            
+            for nei in neis:
+                union(n, nei)
+            
+        return ans