# Evaluate Division LeetCode Solution

Here, We see Evaluate Division LeetCode Solution. This Leetcode problem is done in many programming languages like C++, Java, JavaScript, Python, etc. with different approaches.

# List of all LeetCode Solution

## Problem Statement

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

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

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

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.

Note: The variables that do not occur in the list of equations are undefined, so the answer cannot be determined for them.

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 ] note: x is undefined => -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]

## Evaluate Division LeetCode SolutionC++

``````class Solution {
public:
void dfs(string node, string& dest, unordered_map<string, unordered_map<string, double>>& gr, unordered_set<string>& vis, double& ans, double temp) {
if(vis.find(node) != vis.end()) return;
vis.insert(node);
if(node == dest){
ans = temp;
return;
}
for(auto ne : gr[node]){
dfs(ne.first, dest, gr, vis, ans, temp * ne.second);
}
}
unordered_map<string, unordered_map<string, double>> buildGraph(const vector<vector<string>>& equations, const vector<double>& values) {
unordered_map<string, unordered_map<string, double>> gr;
for (int i = 0; i < equations.size(); i++) {
string dividend = equations[i][0];
string divisor = equations[i][1];
double value = values[i];
gr[dividend][divisor] = value;
gr[divisor][dividend] = 1.0 / value;
}
return gr;
}
vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {
unordered_map<string, unordered_map<string, double>> gr = buildGraph(equations, values);
vector<double> finalAns;
for (auto query : queries) {
string dividend = query[0];
string divisor = query[1];
if (gr.find(dividend) == gr.end() || gr.find(divisor) == gr.end()) {
finalAns.push_back(-1.0);
} else {
unordered_set<string> vis;
double ans = -1, temp=1.0;
dfs(dividend, divisor, gr, vis, ans, temp);
finalAns.push_back(ans);
}
}
return finalAns;
}
};```Code language: JavaScript (javascript)```

## Evaluate Division LeetCode SolutionJava

``````class Solution {
public void dfs(String node, String dest, HashMap<String, HashMap<String, Double>> gr, HashSet<String> vis, double[] ans, double temp) {
if (vis.contains(node))
return;
if (node.equals(dest)) {
ans[0] = temp;
return;
}
for (Map.Entry<String, Double> entry : gr.get(node).entrySet()) {
String ne = entry.getKey();
double val = entry.getValue();
dfs(ne, dest, gr, vis, ans, temp * val);
}
}
public HashMap<String, HashMap<String, Double>> buildGraph(List<List<String>> equations, double[] values) {
HashMap<String, HashMap<String, Double>> gr = new HashMap<>();
for (int i = 0; i < equations.size(); i++) {
String dividend = equations.get(i).get(0);
String divisor = equations.get(i).get(1);
double value = values[i];
gr.putIfAbsent(dividend, new HashMap<>());
gr.putIfAbsent(divisor, new HashMap<>());
gr.get(dividend).put(divisor, value);
gr.get(divisor).put(dividend, 1.0 / value);
}
return gr;
}
public double[] calcEquation(List<List<String>> equations, double[] values, List<List<String>> queries) {
HashMap<String, HashMap<String, Double>> gr = buildGraph(equations, values);
double[] finalAns = new double[queries.size()];
for (int i = 0; i < queries.size(); i++) {
String dividend = queries.get(i).get(0);
String divisor = queries.get(i).get(1);
if (!gr.containsKey(dividend) || !gr.containsKey(divisor)) {
finalAns[i] = -1.0;
} else {
HashSet<String> vis = new HashSet<>();
double[] ans = {-1.0};
double temp = 1.0;
dfs(dividend, divisor, gr, vis, ans, temp);
finalAns[i] = ans[0];
}
}
return finalAns;
}
}```Code language: JavaScript (javascript)```

## Evaluate Division Leetcode SolutionJavaScript

``````var calcEquation = function(equations, values, queries) {
let graph = {};
for (let i = 0; i < equations.length; i++) {
let [numerator, denominator] = equations[i];
let value = values[i];
if (!graph[numerator]) {
graph[numerator] = {};
}
if (!graph[denominator]) {
graph[denominator] = {};
}
graph[numerator][denominator] = value;
graph[denominator][numerator] = 1 / value;
}
let evaluateQuery = (numerator, denominator, visited) => {
if (!(numerator in graph) || !(denominator in graph)) {
return -1.0;
}
if (numerator === denominator) {
return 1.0;
}
let neighbors = graph[numerator];
for (let neighbor in neighbors) {
if (!visited.has(neighbor)) {
let result = evaluateQuery(neighbor, denominator, visited);
if (result !== -1.0) {
return neighbors[neighbor] * result;
}
}
}
return -1.0;
};
let results = [];
for (let query of queries) {
let [numerator, denominator] = query;
let visited = new Set();
let result = evaluateQuery(numerator, denominator, visited);
results.push(result);
}
return results;
};```Code language: JavaScript (javascript)```

## Evaluate Division Leetcode SolutionPython

``````from collections import defaultdict, deque
class Solution:
def calcEquation(self, equations, values, queries):
graph = self.buildGraph(equations, values)
results = []
for dividend, divisor in queries:
if dividend not in graph or divisor not in graph:
results.append(-1.0)
else:
result = self.bfs(dividend, divisor, graph)
results.append(result)
return results
def buildGraph(self, equations, values):
graph = defaultdict(dict)
for (dividend, divisor), value in zip(equations, values):
graph[dividend][divisor] = value
graph[divisor][dividend] = 1.0 / value
return graph
def bfs(self, start, end, graph):
queue = deque([(start, 1.0)])
visited = set()
while queue:
node, value = queue.popleft()
if node == end:
return value