AlgoPressAppearance
题目描述
https://leetcode.cn/problems/evaluate-division
给你一个变量对数组 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 <= 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 由小写英文字母与数字组成
思路:dfs有问题
遍历条件数组，将不存在的符号定义为1，加入hash表，然后根据算术相关的值。 比如 a / b = 2.0 ， 先把 a 作为 1.0 加入进去，计算出 b = 0.5 加入进去 使用 dfs 将与之相关的表达式先运算，比如 [a,b],[c,d],[a,c] 计算 a,b 的时候，递归处理 与 a,b 相关的表达式，比如 a,c 然后再返回上层继续处理 c,d
这个算法有个问题，即 [a,b],[c,d] = [1,1] 这样其实计算的结果应该是-1,因为表达式不能求解，但是因为我们假设了 a = 1, 所以最后结果是1，有问题。
参考代码
csharp
public class Solution {
Dictionary<string,double> dict = new Dictionary<string,double>();
private void dfs(IList<IList<string>> equations, double[] values, int index){
string key1 = equations[index][0];
string key2 = equations[index][1];
if(dict.ContainsKey(key1) && dict.ContainsKey(key2)){
return;
}
//加入hash表
if(!dict.ContainsKey(key1)){
if(!dict.ContainsKey(key2)){
dict.Add(key1,1.0);
dict.Add(key2,1.0/values[index]);
}
else{
dict.Add(key1,dict[key2] * values[index]);
}
}
else{
if(!dict.ContainsKey(key2)){
dict.Add(key2,dict[key1]/values[index]);
}
}
//将与之关联的优先处理
for(int i=index+1; i<equations.Count; i++){
if(equations[i][0] == key1 || equations[i][0] == key2 || equations[i][1] == key1 || equations[i][1] == key2 ) {
dfs(equations,values,i);
}
}
}
public double[] CalcEquation(IList<IList<string>> equations, double[] values, IList<IList<string>> queries) {
// 将符号值加入 hash 表中，如果没有这个key，那么就记录为1.0
// 然后通过表达式换算出其他的值
for(int i=0; i<equations.Count; i++){
dfs(equations,values,i);
}
//输出
double[] result = new double[queries.Count];
for(int i=0; i<queries.Count; i++){
string key1 = queries[i][0];
string key2 = queries[i][1];
if(dict.ContainsKey(key1) && dict.ContainsKey(key2)){
result[i] = dict[key1] / dict[key2];
}
else{
result[i] = -1.0;
}
}
return result;
}
}
思路：并查集
参考代码
csharp
public class Solution {
public class UnionFind{
private int[] parent;
private double[] weight;
public UnionFind(int n){
this.parent = new int[n];
this.weight = new double[n];
for(int i=0; i<n; i++){
parent[i] = i;
weight[i] = 1.0;
}
}
public void union(int x, int y, double value){
int rootX = find(x);
int rootY = find(y);
if(rootX == rootY){
return;
}
parent[rootX] = rootY;
weight[rootX] = weight[y] * value / weight[x];
}
//路径压缩
public int find(int x){
if (x != parent[x]){
int origin = parent[x];
parent[x] = find(parent[x]);
weight[x] *= weight[origin];
}
return parent[x];
}
public double isConnected(int x, int y){
int rootX = find(x);
int rootY = find(y);
if(rootX == rootY){
return weight[x] / weight[y];
}
else{
return -1.0;
}
}
}
public double[] CalcEquation(IList<IList<string>> equations, double[] values, IList<IList<string>> queries) {
int n = equations.Count;
UnionFind unionFind = new UnionFind(2 * n);
//预处理，将变量的值 与 id进行映射，使得并查集的底层使用数组实现，方便编码
Dictionary<string, int> dict = new Dictionary<string,int>();
int id = 0;
for(int i=0; i<n; i++){
string var1 = equations[i][0];
string var2 = equations[i][1];
if(!dict.ContainsKey(var1)){
dict.Add(var1,id);
id++;
}
if(!dict.ContainsKey(var2)){
dict.Add(var2,id);
id++;
}
unionFind.union(dict[var1],dict[var2],values[i]);
}
//做查询
int querieSize = queries.Count;
double[] res = new double[querieSize];
for(int i=0; i<querieSize; i++){
string var1 = queries[i][0];
string var2 = queries[i][1];
if(dict.ContainsKey(var1) && dict.ContainsKey(var2)){
res[i] = unionFind.isConnected(dict[var1],dict[var2]);
}
else{
res[i] = -1.0;
}
}
return res;
}
}