no message

Author: Chris Wu

problems/evaluate-division.py

@@ -56,3 +56,42 @@ def addEdge(n1, n2, val):
 
         return [findVal(query) for query in queries]
 
+
+from collections import defaultdict
+
+class Solution(object):
+    def calcEquation(self, equations, values, queries):
+		#using DFS
+        def find_val(n1, n2):
+            if n1 not in graph or n2 not in graph: return -1
+            if n1==n2: return 1
+            if n2 in graph[n1]: return graph[n1][n2]
+                
+            stack = [(n1, 1)]
+            visited = set()
+            
+            while stack:
+                n, v = stack.pop() #v is the val of n1/n
+				
+                if n in visited: continue
+                visited.add(n)
+                
+                if n==n2:
+                    graph[n1][n2] = v
+                    return v
+                
+                stack.extend([(next_n, v*graph[n][next_n]) for next_n in graph[n]])
+            return -1
+        
+        #build graph
+        graph = defaultdict(dict)
+        for i, v in enumerate(values):
+            n1, n2 = equations[i][0], equations[i][1]
+            graph[n1][n2] = v
+            graph[n2][n1] = 1/v
+        
+        ans = []
+        for n1, n2 in queries:
+            ans.append(find_val(n1, n2))
+            
+        return ans

problems/find-eventual-safe-states.py

@@ -0,0 +1,29 @@
+from collections import defaultdict, deque
+
+class Solution(object):
+    def eventualSafeNodes(self, graph):
+        inbounds = defaultdict(list)
+        outbondsCounter = defaultdict(int)
+        q = deque()
+        ans = []
+        
+        for n, nei_list in enumerate(graph):
+            outbondsCounter[n] = len(nei_list)
+            for nei in nei_list:
+                inbounds[nei].append(n)
+        
+        for n in outbondsCounter:
+            if outbondsCounter[n]==0:
+                q.append(n)
+        
+        while q:
+            n = q.popleft()
+
+            for nei in inbounds[n]:
+                outbondsCounter[nei] -= 1
+                if outbondsCounter[nei]==0:
+                    q.append(nei)
+            
+            ans.append(n)
+        
+        return ans.sort()

problems/satisfiability-of-equality-equations.py

@@ -0,0 +1,57 @@
+from collections import defaultdict
+
+class Solution(object):
+    def equationsPossible(self, equations):
+        def isConnected(n1, n2):
+            if n1==n2: return True
+            
+            stack = [n1]
+            visited = set()
+            
+            while stack:
+                n = stack.pop()
+                if n in visited: continue
+                visited.add(n)
+                
+                if n==n2: return True
+                
+                stack.extend(graph[n])
+            return False
+        
+        not_equals = set()
+        graph = defaultdict(list)
+        
+        #build graph
+        for e in equations:
+            if e[1:3]=='==':
+                graph[e[0]].append(e[3])
+                graph[e[3]].append(e[0])
+            elif e[1:3]=='!=':
+                if (e[0], e[3]) not in not_equals and (e[3], e[0]) not in not_equals:
+                    not_equals.add((e[0], e[3]))
+        
+        #find contradiction
+        for n1, n2 in not_equals:
+            if isConnected(n1, n2): return False
+        
+        return True
+
+"""
+For each `!=` equation, if we find two variables are equal (`isConnected()`), we return `False`.
+Otherwise, we return `True`.
+
+[build graph]
+First, lets build the graph.
+Variables in the same graph means they are all equal.
+
+[find contradiction]
+Second, we find if any "!=" variables (`n1` and `n2`) exist in the same graph.
+Starting from `n1`, if we can find `n2` through DFS, they have the same value.
+
+Time: O(EV).
+Building the graph takes O(E). Finding contradiction takes O(EV).
+E is the number of edges, in this case, `len(equations)`.
+V is the number of nodes, in this case, the unique variables in the equations.
+
+Space: O(V). For the graph.
+"""