# 399. Evaluate Division

Evaluate Division - LeetCode

You are given an array of variable pairs equations and an array of real numbers values, where equations[i] = [Ai, Bi] and values[i] represent the equation Ai / Bi = values[i]. Each Ai or Bi is a string that represents a single variable. You are also given some queries, where queries[j] = [Cj, Dj] represents the jth query where you must find the answer for Cj / Dj = ?. Return the answers to all queries. If a single answer cannot be determined, return -1.0. Note: The input is always valid. You may assume that evaluating the queries will not result in division by zero and that there is no contradiction.

Example 1: Input: equations = [[“a”,“b”],[“b”,“c”]], values = [2.0,3.0], queries = [[“a”,“c”],[“b”,“a”],[“a”,“e”],[“a”,“a”],[“x”,“x”]] Output: [6.00000,0.50000,-1.00000,1.00000,-1.00000] Explanation: Given: a / b = 2.0, b / c = 3.0 queries are: a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ? return: [6.0, 0.5, -1.0, 1.0, -1.0 ] Example 2: Input: equations = [[“a”,“b”],[“b”,“c”],[“bc”,“cd”]], values = [1.5,2.5,5.0], queries = [[“a”,“c”],[“c”,“b”],[“bc”,“cd”],[“cd”,“bc”]] Output: [3.75000,0.40000,5.00000,0.20000] Example 3: Input: equations = [[“a”,“b”]], values = [0.5], queries = [[“a”,“b”],[“b”,“a”],[“a”,“c”],[“x”,“y”]] Output: [0.50000,2.00000,-1.00000,-1.00000]

Constraints:

``````1 <= equations.length <= 20
equations[i].length == 2
1 <= Ai.length, Bi.length <= 5
values.length == equations.length
0.0 < values[i] <= 20.0
1 <= queries.length <= 20
queries[i].length == 2
1 <= Cj.length, Dj.length <= 5
Ai, Bi, Cj, Dj consist of lower case English letters and digits.
``````

• code #unionfind
``````class Solution:
def calcEquation(self, equations: List[List[str]], values: List[float], queries: List[List[str]]) -> List[float]:

dic = {} # node's group root, weight of node its own

def find(x):
if x not in dic:
dic[x] = (x, 1)
group, node_w = dic[x]
if x != group:
# new_group, group_w = find(dic[group])  wrong!
new_group, group_w = find(group) # notice group is already different from x
dic[x] = (new_group, node_w * group_w)
return dic[x]

def union(divided, divisor, value):
divided_group, divided_w = find(divided)
divisor_group, divisor_w = find(divisor)
if divided_group == divisor_group: return
dic[divided_group] = (divisor_group, value * divisor_w / divided_w)

for e, v in zip(equations, values):
union(*e, v)

res = []
for i, j in queries:
if i not in dic or j not in dic:
res.append(-1)
else:
igroup, iw = find(i)
jgroup, jw = find(j)
if igroup != jgroup:
res.append(-1)
else:
res.append(iw/jw)

return res

``````