no message

Author: Chris Wu

problems/flood-fill.py

@@ -0,0 +1,17 @@
+class Solution(object):
+    def floodFill(self, image, sr, sc, newColor):
+        stack = [(sr, sc)]
+        originColor = image[sr][sc]
+        
+        while stack:
+            i, j = stack.pop()
+            
+            if image[i][j]==newColor or image[i][j]!=originColor: continue
+
+            image[i][j] = newColor
+            if i+1<len(image): stack.append((i+1, j))
+            if 0<=i-1: stack.append((i-1, j))
+            if j+1<len(image[0]): stack.append((i, j+1))
+            if 0<=j-1: stack.append((i, j-1))
+
+        return image

problems/friend-circles.py

@@ -72,4 +72,38 @@ def union(p1, p2): #[2]
 
 M = [[1,0,0,1],[0,1,1,0],[0,1,1,1],[1,0,1,1]]
 s = Solution()
-s.findCircleNum(M)
+s.findCircleNum(M)
+
+
+
+# 2020/8/12
+class Solution(object):
+    def findCircleNum(self, M):
+        if not M or not M[0]: return 0
+        count = 0
+        visited = set()
+        
+        for student in xrange(len(M)):
+            if student in visited: continue
+            
+            count += 1
+
+            #dfs
+            stack = [student]
+            while stack:
+                curr_student = stack.pop()
+                if curr_student in visited: continue
+                visited.add(curr_student)
+                stack.extend([class_mate for class_mate, is_friend in enumerate(M[curr_student]) if is_friend])
+                
+        return count
+
+"""
+If you don't know, DFS, please figure it out then come back.
+
+For every `student`, we use DFS to find all of his direct friends. And put them into `visited`.
+Every time we perform a DFS means putting an entire friend circle into `visited`.
+
+Time Complexity: O(N).
+Space Complexity: O(N).
+"""

problems/max-area-of-island.py

@@ -0,0 +1,44 @@
+class Solution(object):
+    def maxAreaOfIsland(self, grid):
+        def dfs(i0, j0):
+            stack = [(i0, j0)]
+            area = 0
+            
+            while stack:
+                i, j = stack.pop()
+                if grid[i][j]==0 or grid[i][j]==2: continue
+                grid[i][j] = 2
+                area += 1
+                
+                if i+1<M: stack.append((i+1, j))
+                if 0<=i-1: stack.append((i-1, j))
+                if j+1<N: stack.append((i, j+1))
+                if 0<=j-1: stack.append((i, j-1))
+            
+            return area
+                
+        if not grid or not grid[0]: return 0
+        
+        max_area = 0
+        M = len(grid)
+        N = len(grid[0])
+        
+        for i in xrange(M):
+            for j in xrange(N):
+                if grid[i][j]==0 or grid[i][j]==2: continue
+                max_area = max(max_area, dfs(i, j))
+                
+        return max_area
+
+"""
+0 means water.
+1 means land.
+2 means land we already visited.
+
+We iterate the map using a double for-loop.
+When we encounter 0 or 2, we skip.
+When we encounter 1, we do a dfs() to mark all the land on the same island as 2. So we don't count it again.
+
+Time: O(N). We iterate all the island once. If visited, we will skip.
+Space: O(1).
+"""

problems/number-of-islands.py

@@ -85,3 +85,45 @@ def explore_adjacent(h_root, w_root):
                     explore_adjacent(h, w)
 
         return count
+
+
+class Solution(object):
+    def numIslands(self, grid):
+        def dfs(i0, j0):
+            stack = [(i0, j0)]
+            
+            while stack:
+                i, j = stack.pop()
+                if grid[i][j]=="0" or grid[i][j]=="2": continue
+                grid[i][j] = "2"
+                
+                if i+1<M: stack.append((i+1, j))
+                if 0<=i-1: stack.append((i-1, j))
+                if j+1<N: stack.append((i, j+1))
+                if 0<=j-1: stack.append((i, j-1))
+                
+        if not grid or not grid[0]: return 0
+        
+        count = 0
+        M = len(grid)
+        N = len(grid[0])
+        
+        for i in xrange(M):
+            for j in xrange(N):
+                if grid[i][j]=="0" or grid[i][j]=="2": continue
+                dfs(i, j)
+                count += 1
+        return count
+
+"""
+0 means water.
+1 means land.
+2 means land we already visited.
+
+We iterate the map using a double for-loop.
+When we encounter 0 or 2, we skip.
+When we encounter 1, we do a dfs() to mark all the land on the same island as 2. So we don't count it again.
+
+Time: O(N). We iterate all the island once. If visited, we will skip.
+Space: O(1).
+"""