给你一个变量对数组 equations 和一个实数值数组 values 作为已知条件，其中 equations[i] = [Ai, Bi] 和 values[i] 共同表示等式 Ai / Bi = values[i] 。每个 Ai 或 Bi 是一个表示单个变量的字符串。
另有一些以数组 queries 表示的问题，其中 queries[j] = [Cj, Dj] 表示第 j 个问题，请你根据已知条件找出 Cj / Dj = ? 的结果作为答案。
返回 所有问题的答案 。如果存在某个无法确定的答案，则用 -1.0 替代这个答案。如果问题中出现了给定的已知条件中没有出现的字符串，也需要用 -1.0 替代这个答案。
注意：输入总是有效的。你可以假设除法运算中不会出现除数为 0 的情况，且不存在任何矛盾的结果。
示例 1：
输入：equations = [["a","b"],["b","c"]], values = [2.0,3.0], queries = [["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：
输入：equations = [["a","b"],["b","c"],["bc","cd"]], values = [1.5,2.5,5.0], queries = [["a","c"],["c","b"],["bc","cd"],["cd","bc"]] 输出：[3.75000,0.40000,5.00000,0.20000]
示例 3：
输入：equations = [["a","b"]], values = [0.5], queries = [["a","b"],["b","a"],["a","c"],["x","y"]] 输出：[0.50000,2.00000,-1.00000,-1.00000]
提示：
1 <= equations.length <= 20equations[i].length == 21 <= Ai.length, Bi.length <= 5values.length == equations.length0.0 < values[i] <= 20.01 <= queries.length <= 20queries[i].length == 21 <= Cj.length, Dj.length <= 5Ai, Bi, Cj, Dj由小写英文字母与数字组成
并查集。对于本题，具备等式关系的所有变量构成同一个集合，同时，需要维护一个权重数组 w，初始时 w[i] = 1。对于等式关系如 a / b = 2，令 w[a] = 2。在 find() 查找祖宗节点的时候，同时进行路径压缩，并更新节点权重。而在合并节点时，p[pa] = pb，同时更新 pa 的权重为 w[pa] = w[b] * (a / b) / w[a]。
以下是并查集的几个常用模板。
模板 1——朴素并查集：
# 初始化，p存储每个点的父节点
p = list(range(n))
# 返回x的祖宗节点
def find(x):
if p[x] != x:
# 路径压缩
p[x] = find(p[x])
return p[x]
# 合并a和b所在的两个集合
p[find(a)] = find(b)模板 2——维护 size 的并查集：
# 初始化，p存储每个点的父节点，size只有当节点是祖宗节点时才有意义，表示祖宗节点所在集合中，点的数量
p = list(range(n))
size = [1] * n
# 返回x的祖宗节点
def find(x):
if p[x] != x:
# 路径压缩
p[x] = find(p[x])
return p[x]
# 合并a和b所在的两个集合
if find(a) != find(b):
size[find(b)] += size[find(a)]
p[find(a)] = find(b)模板 3——维护到祖宗节点距离的并查集：
# 初始化，p存储每个点的父节点，d[x]存储x到p[x]的距离
p = list(range(n))
d = [0] * n
# 返回x的祖宗节点
def find(x):
if p[x] != x:
t = find(p[x])
d[x] += d[p[x]]
p[x] = t
return p[x]
# 合并a和b所在的两个集合
p[find(a)] = find(b)
d[find(a)] = distanceclass Solution:
def calcEquation(
self, equations: List[List[str]], values: List[float], queries: List[List[str]]
) -> List[float]:
def find(x):
if p[x] != x:
origin = p[x]
p[x] = find(p[x])
w[x] *= w[origin]
return p[x]
w = defaultdict(lambda: 1)
p = defaultdict()
for a, b in equations:
p[a], p[b] = a, b
for i, v in enumerate(values):
a, b = equations[i]
pa, pb = find(a), find(b)
if pa == pb:
continue
p[pa] = pb
w[pa] = w[b] * v / w[a]
return [
-1 if c not in p or d not in p or find(c) != find(d) else w[c] / w[d]
for c, d in queries
]class Solution {
private Map<String, String> p;
private Map<String, Double> w;
public double[] calcEquation(
List<List<String>> equations, double[] values, List<List<String>> queries) {
int n = equations.size();
p = new HashMap<>();
w = new HashMap<>();
for (List<String> e : equations) {
p.put(e.get(0), e.get(0));
p.put(e.get(1), e.get(1));
w.put(e.get(0), 1.0);
w.put(e.get(1), 1.0);
}
for (int i = 0; i < n; ++i) {
List<String> e = equations.get(i);
String a = e.get(0), b = e.get(1);
String pa = find(a), pb = find(b);
if (Objects.equals(pa, pb)) {
continue;
}
p.put(pa, pb);
w.put(pa, w.get(b) * values[i] / w.get(a));
}
int m = queries.size();
double[] ans = new double[m];
for (int i = 0; i < m; ++i) {
String c = queries.get(i).get(0), d = queries.get(i).get(1);
ans[i] = !p.containsKey(c) || !p.containsKey(d) || !Objects.equals(find(c), find(d))
? -1.0
: w.get(c) / w.get(d);
}
return ans;
}
private String find(String x) {
if (!Objects.equals(p.get(x), x)) {
String origin = p.get(x);
p.put(x, find(p.get(x)));
w.put(x, w.get(x) * w.get(origin));
}
return p.get(x);
}
}class Solution {
public:
unordered_map<string, string> p;
unordered_map<string, double> w;
vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {
int n = equations.size();
for (auto e : equations) {
p[e[0]] = e[0];
p[e[1]] = e[1];
w[e[0]] = 1.0;
w[e[1]] = 1.0;
}
for (int i = 0; i < n; ++i) {
vector<string> e = equations[i];
string a = e[0], b = e[1];
string pa = find(a), pb = find(b);
if (pa == pb) continue;
p[pa] = pb;
w[pa] = w[b] * values[i] / w[a];
}
int m = queries.size();
vector<double> ans(m);
for (int i = 0; i < m; ++i) {
string c = queries[i][0], d = queries[i][1];
ans[i] = p.find(c) == p.end() || p.find(d) == p.end() || find(c) != find(d) ? -1.0 : w[c] / w[d];
}
return ans;
}
string find(string x) {
if (p[x] != x) {
string origin = p[x];
p[x] = find(p[x]);
w[x] *= w[origin];
}
return p[x];
}
};func calcEquation(equations [][]string, values []float64, queries [][]string) []float64 {
p := make(map[string]string)
w := make(map[string]float64)
for _, e := range equations {
a, b := e[0], e[1]
p[a], p[b] = a, b
w[a], w[b] = 1.0, 1.0
}
var find func(x string) string
find = func(x string) string {
if p[x] != x {
origin := p[x]
p[x] = find(p[x])
w[x] *= w[origin]
}
return p[x]
}
for i, v := range values {
a, b := equations[i][0], equations[i][1]
pa, pb := find(a), find(b)
if pa == pb {
continue
}
p[pa] = pb
w[pa] = w[b] * v / w[a]
}
var ans []float64
for _, e := range queries {
c, d := e[0], e[1]
if p[c] == "" || p[d] == "" || find(c) != find(d) {
ans = append(ans, -1.0)
} else {
ans = append(ans, w[c]/w[d])
}
}
return ans
}