给定一个变量对数组 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 由小写英文字母与数字组成
解题思路
时间0ms,思路不难,建图费劲,双向带权图
这道题的string其实并没用,只是个代号,所以给他代号就好了;
第一次遍历,用哈希set记录所有给已知信息的变量,并建立string到编号的哈希表映射stoid;
第二次遍历,将已知信息存到图里,采用哈希表数组这样的数据结构 vector<unordered_map<string, double> > link;
由第一次的string到编号的映射,可以将除数和值的映射存到被除数的下标下;
例如a / b = 1.5, a对应编号是0,那么link[0]存的就是被除数是a的所有已知信息,包括b到1.5的映射;
同时图是双向的, b/a = 1/1.5,同步建图;
对于每次询问,如果目标不在,对应结果是-1.0,如果除数被除数相同,对应结果是1.0;
除特殊情况外,需要在图中BFS的找相连的关系:
例如a/b = 1.5, b/c = 2,则要在图中找a->b->c,对应结果为边权重相乘;
队列中存变量以及从起始点到当前位置的权重之积,并再用一个哈希set记录已访问节点避免重复无效访问;
代码
class Solution {
private:
vector<unordered_map<string, double> > link;
unordered_map<string, int> stoid;
public:
double com(string a, string b) {
queue<pair<string, double> > q;
unordered_set<string> vis;
vis.insert(a);
q.push({a,1.0});
while(!q.empty()) {
auto [s, val] = q.front();
q.pop();
if(s == b) return val;
for(auto [nexts, nextval] : link[stoid[s]]) {
if(!vis.count(nexts)) {
vis.insert(nexts);
q.push({nexts, val * nextval});
}
}
}
return -1.0;
}
vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {
unordered_set<string> words;
int id = 0;
for(auto e : equations) {
for(int i = 0; i < 2; i++) {
if(!words.count(e[i])) {
words.insert(e[i]);
stoid[e[i]] = id;
id++;
}
}
}
link = vector<unordered_map<string, double> >(id);
for(int i = 0; i < equations.size(); i++) {
string a = equations[i][0], b = equations[i][1];
link[stoid[a]][b] = values[i];
link[stoid[b]][a] = (double) 1 / values[i];
}
int n = queries.size();
vector<double> ans(n);
for(int i = 0; i < n; i++) {
string a = queries[i][0], b = queries[i][1];
if(!words.count(a) || !words.count(b)) ans[i] = -1.0;
else if(a == b) ans[i] = 1.0;
else {
ans[i] = com(a, b);
}
}
return ans;
}
};