부서 평가

변수 쌍 배열equations과 실수 배열values이 주어집니다. 여기서 equations[i] = [Ai, Bi] 및 values[i]는 방정식 Ai / Bi = values[i]를 나타냅니다. 각 Ai 또는 Bi는 단일 변수를 나타내는 문자열입니다.

또한 some queries 가 주어집니다. 여기서 queries[j] = [Cj, Dj] 는 jth 에 대한 답을 찾아야 하는 Cj / Dj = ? 쿼리를 나타냅니다.

모든 쿼리에 대한 답변을 반환합니다. 단일 답변을 결정할 수 없는 경우 -1.0를 반환합니다.

참고: 입력은 항상 유효합니다. 쿼리를 평가해도 0으로 나누지 않고 모순이 없다고 가정할 수 있습니다.

예 1:

입력: 방정식 = [["a","b"],["b","c"]], 값 = [2.0,3.0], 쿼리 = [["a","c"],["b ","a"],["a","e"],["a","a"],["x","x"]]
출력: [6.00000,0.50000,-1.00000,1.00000,-1.00000]
설명:
주어진: a/b = 2.0, b/c = 3.0
쿼리는 a/c = ?, b/a = ?, a/e = ?, a/a = ?, x/x = ?
반환: [6.0, 0.5, -1.0, 1.0, -1.0]

예 2:

입력: 방정식 = [["a","b"],["b","c"],["bc","cd"]], 값 = [1.5,2.5,5.0], 쿼리 = [[ "a","c"],["c","b"],["bc","cd"],["cd","bc"]]
출력: [3.75000,0.40000,5.00000,0.20000]

예 3:

입력: 방정식 = [["a","b"]], 값 = [0.5], 쿼리 = [["a","b"],["b","a"],["a", "c"],["x","y"]]
출력: [0.50000,2.00000,-1.00000,-1.00000]

제약:

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 영문 소문자와 숫자로 구성됩니다.

해결책:

class Solution:
    def calcEquation(self, equations: List[List[str]], values: List[float], queries: List[List[str]]) -> List[float]:
        graph = {}
        n = len(equations)
        for i in range(n):
            a, b = equations[i]
            graph[a] = graph.get(a, []) + [(b, values[i])]
            graph[b] = graph.get(b, []) + [(a, 1 / values[i])]
        op = []
        for c, d in queries:
            found = False
            paths = [(c, 1, {c})]
            while len(paths) > 0:
                curr, prod, visited = paths.pop()
                if curr not in graph:
                    break
                if curr == d:
                    op.append(prod)
                    found = True
                    break
                for j, div in graph.get(curr, []):
                    if j not in visited:
                        paths.append((j, prod * div, visited.union({j})))
            if not found:
                op.append(-1.0)
        return op