LeetCode in Net

399. Evaluate Division

Medium

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

You are also given some queries, where queries[j] = [C_j, D_j] represents the j^th query where you must find the answer for C_j / D_j = ?.

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.

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 <= A_i.length, B_i.length <= 5
values.length == equations.length
0.0 < values[i] <= 20.0
1 <= queries.length <= 20
queries[i].length == 2
1 <= C_j.length, D_j.length <= 5
A_i, B_i, C_j, D_j consist of lower case English letters and digits.

Solution

using System;
using System.Collections.Generic;

public class Solution {
    private Dictionary<string, string> root;
    private Dictionary<string, double> rate;

    public double[] CalcEquation(
            IList<IList<string>> equations, double[] values, IList<IList<string>> queries) {
        root = new Dictionary<string, string>();
        rate = new Dictionary<string, double>();
        int n = equations.Count;
        foreach (var equation in equations) {
            string x = equation[0];
            string y = equation[1];
            root[x] = x;
            root[y] = y;
            rate[x] = 1.0;
            rate[y] = 1.0;
        }
        for (int i = 0; i < n; ++i) {
            string x = equations[i][0];
            string y = equations[i][1];
            union(x, y, values[i]);
        }
        double[] result = new double[queries.Count];
        for (int i = 0; i < queries.Count; ++i) {
            string x = queries[i][0];
            string y = queries[i][1];
            if (!root.ContainsKey(x) || !root.ContainsKey(y)) {
                result[i] = -1;
                continue;
            }
            string rootX = findRoot(x, x, 1.0);
            string rootY = findRoot(y, y, 1.0);
            result[i] = rootX.Equals(rootY) ? rate[x] / rate[y] : -1.0; 
        }
        return result;
    }

    private void union(string x, string y, double v) {
        string rootX = findRoot(x, x, 1.0);
        string rootY = findRoot(y, y, 1.0);
        root[rootX] = rootY;
        double r1 = rate[x];
        double r2 = rate[y];
        rate[rootX] = v * r2 / r1;
    }

    private string findRoot(string originalX, string x, double r) {
        if (root[x].Equals(x)) {
            root[originalX] = x;
            rate[originalX] = r * rate[x];
            return x;
        }
        return findRoot(originalX, root[x], r * rate[x]);
    }
}

This site is open source. Improve this page.