solution/0300-0399/0399.Evaluate Division/README_EN.md · zjut2022/leetcode

# [399. Evaluate Division](https://leetcode.com/problems/evaluate-division)

[中文文档](/solution/0300-0399/0399.Evaluate%20Division/README.md)

## Description

You are given an array of variable pairs <code>equations</code> and an array of real numbers <code>values</code>, where <code>equations[i] = [Ai, Bi]</code> and <code>values[i]</code> represent the equation <code>Ai / Bi = values[i]</code>. Each <code>Ai</code> or <code>Bi</code> is a string that represents a single variable.

You are also given some <code>queries</code>, where <code>queries[j] = [Cj, Dj]</code> represents the <code>jth</code> query where you must find the answer for <code>Cj / Dj = ?</code>.

Return the answers to all queries. If a single answer cannot be determined, return <code>-1.0</code>.

Note: The input is always valid. You may assume that evaluating the queries will not result in division by zero and that there is no contradiction.

&nbsp;
Example 1:

<pre>
Input: equations = [[&quot;a&quot;,&quot;b&quot;],[&quot;b&quot;,&quot;c&quot;]], values = [2.0,3.0], queries = [[&quot;a&quot;,&quot;c&quot;],[&quot;b&quot;,&quot;a&quot;],[&quot;a&quot;,&quot;e&quot;],[&quot;a&quot;,&quot;a&quot;],[&quot;x&quot;,&quot;x&quot;]]
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 ]
</pre>

Example 2:

<pre>
Input: equations = [[&quot;a&quot;,&quot;b&quot;],[&quot;b&quot;,&quot;c&quot;],[&quot;bc&quot;,&quot;cd&quot;]], values = [1.5,2.5,5.0], queries = [[&quot;a&quot;,&quot;c&quot;],[&quot;c&quot;,&quot;b&quot;],[&quot;bc&quot;,&quot;cd&quot;],[&quot;cd&quot;,&quot;bc&quot;]]
Output: [3.75000,0.40000,5.00000,0.20000]
</pre>

Example 3:

<pre>
Input: equations = [[&quot;a&quot;,&quot;b&quot;]], values = [0.5], queries = [[&quot;a&quot;,&quot;b&quot;],[&quot;b&quot;,&quot;a&quot;],[&quot;a&quot;,&quot;c&quot;],[&quot;x&quot;,&quot;y&quot;]]
Output: [0.50000,2.00000,-1.00000,-1.00000]
</pre>

&nbsp;
Constraints:

<ul>
	<li><code>1 &lt;= equations.length &lt;= 20</code></li>
	<li><code>equations[i].length == 2</code></li>
	<li><code>1 &lt;= Ai.length, Bi.length &lt;= 5</code></li>
	<li><code>values.length == equations.length</code></li>
	<li><code>0.0 &lt; values[i] &lt;= 20.0</code></li>
	<li><code>1 &lt;= queries.length &lt;= 20</code></li>
	<li><code>queries[i].length == 2</code></li>
	<li><code>1 &lt;= Cj.length, Dj.length &lt;= 5</code></li>
	<li><code>Ai, Bi, Cj, Dj</code> consist of lower case English letters and digits.</li>
</ul>

## Solutions

Union find.

### **Python3**

```python
class 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]
```

### **Java**

```java
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);
    }
}
```

### **C++**

```cpp
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];
    }
};
```

### **Go**

```go
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
}
```

### **...**

```

zjut2022/leetcode

简介

发行版

贡献者

近期动态

zjut2022/leetcode .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

zjut2022/leetcode