# Evaluate Division (M)

## 题目

You are given `equations` in the format `A / B = k`, where `A` and `B` are variables represented as strings, and `k` is a real number (floating-point number). Given some `queries`, return the answers. If the answer does not exist, return `-1.0`.

The input is always valid. You may assume that evaluating the queries will result in no division by zero and 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 <= equations[i][0], equations[i][1] <= 5`
• `values.length == equations.length`
• `0.0 < values[i] <= 20.0`
• `1 <= queries.length <= 20`
• `queries[i].length == 2`
• `1 <= queries[i][0], queries[i][1] <= 5`
• `equations[i][0], equations[i][1], queries[i][0], queries[i][1]` consist of lower case English letters and digits.

## 题意

给定一系列字符串之间的比值，求另一组字符串对的比值。

## 思路

DFS搜索。将所有字符串对及其倒数存入Map。对于每个需要查询的(frac{A}{B})，如果存在则直接返回，如果不存在则拆分成(frac{A}{C} imesfrac{C}{B})，递归查询(frac{C}{B})

## 代码实现

### Java

``````class Solution {
public double[] calcEquation(List<List<String>> equations, double[] values, List<List<String>> queries) {
double[] ans = new double[queries.size()];
Map<String, Map<String, Double>> hash = new HashMap<>();
for (int i = 0; i < values.length; i++) {
String A = equations.get(i).get(0);
String B = equations.get(i).get(1);
hash.putIfAbsent(A, new HashMap<>());
hash.get(A).put(B, values[i]);
hash.putIfAbsent(B, new HashMap<>());
hash.get(B).put(A, 1.0 / values[i]);
}
for (int i = 0; i < queries.size(); i++) {
List<String> query = queries.get(i);
ans[i] = dfs(query.get(0), query.get(1), hash, new HashSet<>());
}
return ans;
}

private double dfs(String A, String B, Map<String, Map<String, Double>> hash, Set<String> visited) {
if (!hash.containsKey(A)) {
return -1.0;
}
if (A == B) {
return 1.0;
}
if (hash.get(A).containsKey(B)) {
return hash.get(A).get(B);
}
for (String C : hash.get(A).keySet()) {
if (!visited.contains(C)) {
double tmp = dfs(C, B, hash, visited);
if (tmp > 0) {
return hash.get(A).get(C) * tmp;
}
}
}
return -1.0;
}
}
``````
• 相关阅读:
后向边
图的割点、桥和双连通分支的基本概念
Hihocoder 1062 最近公共祖先1
会场问题 差分解法
POJ2976 01分数规划 普通题
Hihocoder 1049
hihocoder 1050树中最长路
Hihocoder 1055
POJ1463
C语言|博课作业02
• 原文地址：https://www.cnblogs.com/mapoos/p/13744226.html