updates

Author: wuduhren

problems/python3/alien-dictionary.py

@@ -0,0 +1,36 @@
+class Solution:
+    def alienOrder(self, words: List[str]) -> str:
+        adj = collections.defaultdict(list)
+        inbounds = collections.Counter()
+        q = collections.deque()
+        ans = ''
+        
+        adj = {c: set() for word in words for c in word}
+        for i in range(len(words)-1):
+            w1, w2 = words[i], words[i+1]
+            minLen = min(len(w1), len(w2))
+            if w1[:minLen]==w2[:minLen] and len(w1)>len(w2): return ""
+            
+            for j in range(minLen):
+                if w1[j]!=w2[j]:
+                    adj[w1[j]].add(w2[j])
+                    break
+        
+        for c in adj:
+            for nc in list(adj[c]):
+                inbounds[nc] += 1
+        
+        for c in adj:
+            if inbounds[c]==0: q.append(c)
+        
+        while q:
+            c = q.popleft()
+            
+            ans += c
+            
+            for nc in adj[c]:
+                inbounds[nc] -= 1
+                if inbounds[nc]==0: q.append(nc)
+        
+        return ans if len(ans)==len(adj) else ''
+

problems/python3/cheapest-flights-within-k-stops.py

@@ -0,0 +1,17 @@
+"""
+Bellman-Ford.
+Time: O(KE)
+"""
+class Solution:
+    def findCheapestPrice(self, N: int, flights: List[List[int]], src: int, dst: int, K: int) -> int:
+        prices = {n:float('inf') for n in range(N)}
+        prices[src] = 0
+        
+        for k in range(K+1):
+            temp = prices.copy()
+            for source, destination, price in flights:
+                if prices[source]==float('inf'): continue
+                if prices[source]+price<temp[destination]:
+                    temp[destination] = prices[source]+price
+            prices = temp
+        return prices[dst] if prices[dst]!=float('inf') else -1

problems/python3/climbing-stairs.py

@@ -0,0 +1,10 @@
+class Solution:
+    def climbStairs(self, N: int) -> int:
+        dp = [0]*(N+1)
+        dp[0] = 1
+        for i in range(len(dp)):
+            if i-1>=0:
+                dp[i] += dp[i-1]
+            if i-2>=0:
+                dp[i] += dp[i-2]
+        return dp[-1]

problems/python3/min-cost-climbing-stairs.py

@@ -0,0 +1,16 @@
+"""
+Time: O(N)
+Space: O(N), can further reduce to using only 2 variables -> O(1).
+
+dp[i] := the cost to get to index i.
+"""
+class Solution:
+    def minCostClimbingStairs(self, cost: List[int]) -> int:
+        N = len(cost)
+        dp = [float('inf')]*(N+1)
+        dp[0] = 0
+        dp[1] = 0
+        
+        for i in range(2, len(dp)):
+            dp[i] = min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2])
+        return dp[-1]

problems/python3/min-cost-to-connect-all-points.py

@@ -0,0 +1,28 @@
+class Solution:
+    def minCostConnectPoints(self, points: List[List[int]]) -> int:
+        ans = 0
+        visited = set()
+        adj = collections.defaultdict(list)
+        N = len(points)
+        
+        #build adjacency list
+        for i in range(N):
+            x0, y0 = points[i]
+            for j in range(i+1, N):
+                x1, y1 = points[j]
+                dis = abs(x0-x1)+abs(y0-y1)
+                adj[(x0, y0)].append((dis, x1, y1))
+                adj[(x1, y1)].append((dis, x0, y0))
+        
+        h = [(0, points[0][0], points[0][1])] #min heap
+        while len(visited)<N:
+            dis, x, y = heapq.heappop(h)
+            
+            if (x, y) in visited: continue
+            visited.add((x, y))
+            ans += dis
+            
+            for dis1, x1, y1 in adj[(x, y)]:
+                if (x1, y1) in visited: continue
+                heapq.heappush(h, (dis1, x1, y1))
+        return ans

problems/python3/network-delay-time.py

@@ -0,0 +1,23 @@
+class Solution:
+    def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:
+        ans = 0
+        adj = collections.defaultdict(list)
+        h = []
+        visited = set()
+        
+        for u, v, w in times:
+            adj[u].append((v, w))
+            
+        heapq.heappush(h, (0, k))
+        while h:
+            timeNeededToGetHere, node = heapq.heappop(h)
+            
+            if node in visited: continue
+            visited.add(node)
+            ans = max(ans, timeNeededToGetHere)
+            
+            for nei, time in adj[node]:
+                if nei in visited: continue
+                heapq.heappush(h, (time+timeNeededToGetHere, nei))
+        
+        return ans if len(visited)==n else -1

problems/python3/reconstruct-itinerary.py

@@ -0,0 +1,27 @@
+"""
+DFS with backtracking.
+"""
+class Solution:
+    def findItinerary(self, tickets: List[List[str]]) -> List[str]:
+        def dfs(start) -> bool:
+            if len(ans)==len(tickets)+1: return True
+            if start not in adj: return False
+            
+            temp = list(adj[start])
+            for i, arr in enumerate(temp):
+                adj[start].pop(i)
+                ans.append(arr)
+                if dfs(arr): return True
+                adj[start].insert(i, arr)
+                ans.pop()
+            return False
+        
+        ans = ['JFK']
+        adj = collections.defaultdict(list)
+        
+        tickets.sort()
+        for des, arr in tickets:
+            adj[des].append(arr)
+        
+        dfs('JFK')
+        return ans

problems/python3/swim-in-rising-water.py

@@ -0,0 +1,23 @@
+"""
+Time: O(N^2 * LogN^2) = O(N^2 * 2LogN) = O(N^2LogN), N is the number of elements in a row or column.
+Space: O(N^2)
+"""
+class Solution:
+    def swimInWater(self, grid: List[List[int]]) -> int:
+        ROWS = len(grid)
+        COLS = len(grid[0])
+        
+        visited = set()
+        h = [(grid[0][0], 0, 0)]
+        
+        while h:
+            t, r0, c0 = heapq.heappop(h)
+            
+            if (r0, c0) in visited: continue
+            visited.add((r0, c0))
+            if r0==ROWS-1 and c0==COLS-1: return t
+            
+            for r, c in ((r0+1, c0), (r0-1, c0), (r0, c0+1), (r0, c0-1)):
+                if r<0 or c<0 or r>=ROWS or c>=COLS: continue
+                if (r, c) in visited: continue
+                heapq.heappush(h, (max(t, grid[r][c]), r, c))

problems/python3/word-ladder.py

@@ -0,0 +1,40 @@
+"""
+Time: O(NxM^2). N is the number of words. M is the length of the word.
+Note that, getPatterns() takes O(M^2) since creating new string will also takes O(M) and for each word we do that O(M) times.
+
+Space: O(NxM^2)
+"""
+class Solution:
+    def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
+        def getPatterns(word) -> List[str]:
+            patterns = []
+            for i in range(len(word)):
+                pattern = word[:i]+'*'+word[i+1:]
+                patterns.append(pattern)
+            return patterns
+        
+        
+        if endWord not in wordList: return 0
+        wordList.append(beginWord)
+        
+        #build adjacency list
+        nei = collections.defaultdict(list)
+        for word in wordList:
+            for pattern in getPatterns(word):
+                nei[pattern].append(word)
+        
+        #BFS
+        q = collections.deque([(beginWord, 1)])
+        visited = set()
+        while q:
+            word, steps = q.popleft()
+            
+            if word in visited: continue
+            visited.add(word)
+            if word==endWord: return steps
+            
+            for pattern in getPatterns(word):
+                for nextWord in nei[pattern]:
+                    if nextWord in visited: continue
+                    q.append((nextWord, steps+1))
+        return 0