updates

Author: wuduhren

problems/python3/clone-graph.py

@@ -0,0 +1,16 @@
+class Solution:
+    def cloneGraph(self, start: 'Node') -> 'Node':
+        def dfs(node):
+            if node in clones: return clones[node]
+            
+            copy = Node(node.val)
+            clones[node] = copy
+            
+            for neighbor in node.neighbors:
+                copy.neighbors.append(dfs(neighbor))
+                
+            return clones[node]
+        if not start: return start
+        clones = {}
+        dfs(start)
+        return clones[start]

problems/python3/course-schedule-ii.py

@@ -0,0 +1,30 @@
+#Topological Sort
+class Solution:
+    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
+        sortedCourse = []
+        G = collections.defaultdict(list) #graph
+        inbounds = collections.Counter()
+        q = collections.deque()
+        
+        #build graph
+        for c1, c2 in prerequisites:
+            G[c2].append(c1)
+            inbounds[c1] += 1
+        
+        #add the starting point to the q. (the ones that have 0 inbounds)
+        for course in range(numCourses):
+            if inbounds[course]==0: q.append(course)
+        
+        #add the course that have 0 inbounds to the sortedCourse.
+        #after that, imagine we remove it from the graph, so nextCourse inbound will -1
+        #add to q if nextCourse have 0 inbounds
+        while q:
+            course = q.popleft()
+            
+            sortedCourse.append(course)
+            
+            for nextCourse in G[course]:
+                inbounds[nextCourse] -= 1
+                if inbounds[nextCourse]==0: q.append(nextCourse)
+        
+        return sortedCourse if len(sortedCourse)==numCourses else []

problems/python3/course-schedule.py

@@ -0,0 +1,23 @@
+class Solution:
+    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+        sortedCourse = []
+        inbounds = collections.Counter()
+        G = collections.defaultdict(list)
+        q = collections.deque()
+        
+        for c1, c2 in prerequisites:
+            G[c2].append(c1)
+            inbounds[c1] += 1
+        
+        for c in range(numCourses):
+            if inbounds[c]==0: q.append(c)
+
+        while q:
+            c = q.popleft()
+            
+            for c2 in G[c]:
+                inbounds[c2] -= 1
+                if inbounds[c2]==0: q.append(c2)    
+            sortedCourse.append(c)
+        
+        return len(sortedCourse)==numCourses

problems/python3/design-add-and-search-words-data-structure.py

@@ -0,0 +1,33 @@
+class WordDictionary:
+
+    def __init__(self):
+        self.root = {}
+
+    def addWord(self, word: str) -> None:
+        node = self.root
+        for c in word:
+            if c not in node: node[c] = {}
+            node = node[c]
+        node['$'] = {} #'.' means the end of the word
+
+    def search(self, word: str) -> bool:
+        def helper(node, i):
+            if i==len(word): return '$' in node
+                
+            if word[i]=='.':
+                for c in node:
+                    if helper(node[c], i+1): return True
+                return False
+            else:
+                if word[i] not in node: return False
+                return helper(node[word[i]], i+1)
+        return helper(self.root, 0)
+            
+        
+        
+        
+        
+    
+    
+    
+    

problems/python3/implement-trie-prefix-tree.py

@@ -0,0 +1,26 @@
+class Trie:
+
+    def __init__(self):
+        self.root = {}
+
+    def insert(self, word: str) -> None:
+        node = self.root
+        for c in word:
+            if c not in node: node[c] = {}
+            node = node[c]
+        node['.'] = {} #'.' means the end of the word
+        
+        
+    def search(self, word: str) -> bool:
+        node = self.root
+        for c in word:
+            if c not in node: return False
+            node = node[c]
+        return '.' in node
+
+    def startsWith(self, prefix: str) -> bool:
+        node = self.root
+        for c in prefix:
+            if c not in node: return False
+            node = node[c]
+        return True

problems/python3/max-area-of-island.py

@@ -0,0 +1,23 @@
+class Solution:
+    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
+        def dfs(i, j) -> int:
+            if i<0 or j<0 or i>=MAX_ROW or j>=MAX_COL: return 0
+            if grid[i][j]==0 or grid[i][j]==2: return 0
+            
+            grid[i][j] = 2 #mark as visited
+            
+            area = 1
+            area += dfs(i+1, j)
+            area += dfs(i-1, j)
+            area += dfs(i, j+1)
+            area += dfs(i, j-1)
+            return area
+            
+        ans = 0
+        MAX_ROW = len(grid)
+        MAX_COL = len(grid[0])
+        
+        for i in range(MAX_ROW):
+            for j in range(MAX_COL):
+                ans = max(ans, dfs(i, j))
+        return ans

problems/python3/number-of-islands.py

@@ -0,0 +1,22 @@
+class Solution:
+    def numIslands(self, grid: List[List[str]]) -> int:
+        def dfs(i, j):
+            if i<0 or j<0 or i>=MAX_ROWS or j>=MAX_COLS: return
+            if grid[i][j]!='1': return
+            
+            grid[i][j] = '2'
+            dfs(i+1, j)
+            dfs(i-1, j)
+            dfs(i, j+1)
+            dfs(i, j-1)
+        
+        count = 0
+        MAX_ROWS = len(grid)
+        MAX_COLS = len(grid[0])
+        
+        for i in range(MAX_ROWS):
+            for j in range(MAX_COLS):
+                if grid[i][j]=='1':
+                    dfs(i, j)
+                    count += 1
+        return count

problems/python3/pacific-atlantic-water-flow.py

@@ -0,0 +1,30 @@
+class Solution:
+    def pacificAtlantic(self, heights: List[List[int]]) -> List[List[int]]:
+        def bfs(q, ocian):
+            while q:
+                i0, j0 = q.popleft()
+                if (i0, j0) in ocian: continue
+                ocian.add((i0, j0))
+                
+                for i, j in ((i0+1, j0), (i0-1, j0), (i0, j0+1), (i0, j0-1)):
+                    if i<0 or j<0 or i>=MAX_ROW or j>=MAX_COL: continue
+                    if heights[i][j]>=heights[i0][j0]: q.append((i, j))
+                    
+        MAX_ROW = len(heights)
+        MAX_COL = len(heights[0])
+        
+        #add the top and left to q1
+        pacific = set()
+        q1 = collections.deque()
+        for j in range(MAX_COL): q1.append((0, j))
+        for i in range(MAX_ROW): q1.append((i, 0))
+            
+        #add botton and right to q2
+        atlantic = set()
+        q2 = collections.deque()
+        for j in range(MAX_COL): q2.append((MAX_ROW-1, j))
+        for i in range(MAX_ROW): q2.append((i, MAX_COL-1))
+            
+        bfs(q1, pacific)
+        bfs(q2, atlantic)
+        return pacific.intersection(atlantic)

problems/python3/rotting-oranges.py

@@ -0,0 +1,35 @@
+class Solution:
+    def orangesRotting(self, grid: List[List[int]]) -> int:
+        time = 0
+        rotten = set()
+        aboutToRot = set()
+        fresh = set()
+        
+        for i in range(len(grid)):
+            for j in range((len(grid[0]))):
+                if grid[i][j]==2:
+                    rotten.add((i, j))
+                elif grid[i][j]==1:
+                    fresh.add((i, j))
+        
+        while rotten:
+            i0, j0 = rotten.pop() #randomly get one
+            grid[i0][j0] = 2
+            
+            for i, j in ((i0+1, j0), (i0-1, j0), (i0, j0+1), (i0, j0-1)):
+                if i<0 or j<0 or i>=len(grid) or j>=len(grid[0]): continue
+                if (i, j) in rotten or (i, j) in aboutToRot: continue
+                if (i, j) in fresh:
+                    fresh.remove((i, j))
+                    aboutToRot.add((i, j))
+            
+            if not rotten and not aboutToRot: break
+            
+            if not rotten:
+                time += 1
+                rotten = aboutToRot
+                aboutToRot = set()
+                
+        if fresh: return -1
+        
+        return time

problems/python3/surrounded-regions.py

@@ -0,0 +1,34 @@
+"""
+Time: O(N)
+Space: O(N)
+"""
+class Solution:
+    def solve(self, board: List[List[str]]) -> None:
+        def dfs(i0, j0):
+            if i0<0 or j0<0 or i0>=MAX_ROW or j0>=MAX_COL: return
+            if board[i0][j0]!='O': return
+            if (i0, j0) in survived: return
+            
+            survived.add((i0, j0))
+            dfs(i0+1, j0)
+            dfs(i0-1, j0)
+            dfs(i0, j0+1)
+            dfs(i0, j0-1)
+        
+        
+        MAX_ROW = len(board)
+        MAX_COL = len(board[0])
+        survived = set()
+        
+        for i in range(MAX_ROW):
+            dfs(i, 0)
+            dfs(i, MAX_COL-1)
+        
+        for j in range(MAX_COL):
+            dfs(0, j)
+            dfs(MAX_ROW-1, j)
+        
+        for i in range(MAX_ROW):
+            for j in range(MAX_COL):
+                board[i][j] = 'O' if (i, j) in survived else 'X'
+        return board

problems/python3/walls-and-gates.py

@@ -0,0 +1,29 @@
+class Solution:
+    def wallsAndGates(self, rooms: List[List[int]]) -> None:
+        def bfs(i0, j0) -> None:
+            q = collections.deque([(i0+1, j0, 1), (i0-1, j0, 1), (i0, j0+1, 1), (i0, j0-1, 1)])
+            visited = set()
+            
+            while q:
+                i, j, dis = q.popleft()
+                
+                if i<0 or j<0 or i>=MAX_ROW or j>=MAX_COL: continue
+                if rooms[i][j]==0 or rooms[i][j]==-1: continue
+                if (i, j, dis) in visited: continue
+                visited.add((i, j, dis))
+                
+                if dis<rooms[i][j]:
+                    rooms[i][j] = dis
+                    q.append((i+1, j, dis+1))
+                    q.append((i-1, j, dis+1))
+                    q.append((i, j+1, dis+1))
+                    q.append((i, j-1, dis+1))
+                
+        MAX_ROW = len(rooms)
+        MAX_COL = len(rooms[0])
+        
+        for i in range(MAX_ROW):
+            for j in range(MAX_COL):
+                if rooms[i][j]==0:
+                    bfs(i, j)
+        return rooms

problems/python3/word-search-ii.py

@@ -0,0 +1,54 @@
+"""
+Time: O(M * 4 * 3^(L-1)), M is board elements count, L is the average word length.
+Space: O(N), N is the number of char in the words
+
+This solution will TLE. We need to further "prune" the trie once we reach the leaf node.
+"""
+class TrieNode():
+    def __init__(self):
+        self.children = {}
+        self.isEnd = False
+    def addWord(self, word):
+        curr = self
+        for c in word:
+            if c not in curr.children:
+                curr.children[c] = TrieNode()
+            curr = curr.children[c]
+        curr.isEnd = True
+    
+class Solution:
+    def findWords(self, board: List[List[str]], words: List[str]) -> List[str]:
+        def dfs(r, c, node, word):
+            if c<0 or r<0 or c==COLS or r==ROWS: return
+            if board[r][c] not in node.children: return
+            if (r, c) in visited: return
+            
+            visited.add((r, c))
+            node = node.children[board[r][c]]
+            word += board[r][c]
+            if node.isEnd:
+                ans.add(word)
+                node.isEnd = False
+                
+            dfs(r+1, c, node, word)
+            dfs(r-1, c, node, word)
+            dfs(r, c+1, node, word)
+            dfs(r, c-1, node, word)
+            
+            visited.remove((r, c))
+        
+        
+        root = TrieNode()
+        for word in words:
+            root.addWord(word)
+            
+        ROWS = len(board)
+        COLS = len(board[0])
+        
+        visited = set()
+        ans = set()
+        node = root
+        for r in range(ROWS):
+            for c in range(COLS):
+                dfs(r, c, root, '')
+        return ans