Welcome to Subscribe On Youtube

399. Evaluate Division

Description

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]

 

Constraints:

  • 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 consist of lower case English letters and digits.

Solutions

Union find.

  • 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);
        }
    }
    
  • 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];
        }
    };
    
  • 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
            ]
    
    
  • 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
    }
    
  • use std::collections::HashMap;
    
    #[derive(Debug)]
    pub struct DSUNode {
        parent: String,
        weight: f64,
    }
    
    pub struct DisjointSetUnion {
        nodes: HashMap<String, DSUNode>,
    }
    
    impl DisjointSetUnion {
        pub fn new(equations: &Vec<Vec<String>>) -> DisjointSetUnion {
            let mut nodes = HashMap::new();
            for equation in equations.iter() {
                for iter in equation.iter() {
                    nodes.insert(iter.clone(), DSUNode {
                        parent: iter.clone(),
                        weight: 1.0,
                    });
                }
            }
            DisjointSetUnion { nodes }
        }
    
        pub fn find(&mut self, v: &String) -> String {
            let origin = self.nodes[v].parent.clone();
            if origin == *v {
                return origin;
            }
    
            let root = self.find(&origin);
            self.nodes.get_mut(v).unwrap().parent = root.clone();
            self.nodes.get_mut(v).unwrap().weight *= self.nodes[&origin].weight;
            root
        }
    
        pub fn union(&mut self, a: &String, b: &String, v: f64) {
            let pa = self.find(a);
            let pb = self.find(b);
            if pa == pb {
                return;
            }
            let (wa, wb) = (self.nodes[a].weight, self.nodes[b].weight);
            self.nodes.get_mut(&pa).unwrap().parent = pb;
            self.nodes.get_mut(&pa).unwrap().weight = (wb * v) / wa;
        }
    
        pub fn exist(&mut self, k: &String) -> bool {
            self.nodes.contains_key(k)
        }
    
        pub fn calc_value(&mut self, a: &String, b: &String) -> f64 {
            if !self.exist(a) || !self.exist(b) || self.find(a) != self.find(b) {
                -1.0
            } else {
                let wa = self.nodes[a].weight;
                let wb = self.nodes[b].weight;
                wa / wb
            }
        }
    }
    
    impl Solution {
        pub fn calc_equation(
            equations: Vec<Vec<String>>,
            values: Vec<f64>,
            queries: Vec<Vec<String>>
        ) -> Vec<f64> {
            let mut dsu = DisjointSetUnion::new(&equations);
            for (i, &v) in values.iter().enumerate() {
                let (a, b) = (&equations[i][0], &equations[i][1]);
                dsu.union(a, b, v);
            }
    
            let mut ans = vec![];
            for querie in queries {
                let (c, d) = (&querie[0], &querie[1]);
                ans.push(dsu.calc_value(c, d));
            }
            ans
        }
    }
    
    
  • function calcEquation(equations: string[][], values: number[], queries: string[][]): number[] {
        const g: Record<string, [string, number][]> = {};
        const ans = Array.from({ length: queries.length }, () => -1);
    
        for (let i = 0; i < equations.length; i++) {
            const [a, b] = equations[i];
            (g[a] ??= []).push([b, values[i]]);
            (g[b] ??= []).push([a, 1 / values[i]]);
        }
    
        for (let i = 0; i < queries.length; i++) {
            const [c, d] = queries[i];
            const vis = new Set<string>();
            const q: [string, number][] = [[c, 1]];
    
            if (!g[c] || !g[d]) continue;
            if (c === d) {
                ans[i] = 1;
                continue;
            }
    
            for (const [current, v] of q) {
                if (vis.has(current)) continue;
                vis.add(current);
    
                for (const [intermediate, multiplier] of g[current]) {
                    if (vis.has(intermediate)) continue;
    
                    if (intermediate === d) {
                        ans[i] = v * multiplier;
                        break;
                    }
    
                    q.push([intermediate, v * multiplier]);
                }
    
                if (ans[i] !== -1) break;
            }
        }
    
        return ans;
    }
    
    

All Problems

All Solutions