399. 除法求值

399. 除法求值

给出方程式 A / B = k, 其中 A 和 B 均为用字符串表示的变量， k 是一个浮点型数字。根据已知方程式求解问题，并返回计算结果。如果结果不存在，则返回 -1.0。

输入总是有效的。你可以假设除法运算中不会出现除数为 0 的情况，且不存在任何矛盾的结果。

 

示例 1：

输入：equations = [["a","b"],["b","c"]], values = [2.0,3.0], queries = [["a","c"],["b","a"],["a","e"],["a","a"],["x","x"]]
输出：[6.00000,0.50000,-1.00000,1.00000,-1.00000]
解释：
给定：a / b = 2.0, b / c = 3.0
问题：a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ?
返回：[6.0, 0.5, -1.0, 1.0, -1.0 ]
示例 2：

输入：equations = [["a","b"],["b","c"],["bc","cd"]], values = [1.5,2.5,5.0], queries = [["a","c"],["c","b"],["bc","cd"],["cd","bc"]]
输出：[3.75000,0.40000,5.00000,0.20000]
示例 3：

输入：equations = [["a","b"]], values = [0.5], queries = [["a","b"],["b","a"],["a","c"],["x","y"]]
输出：[0.50000,2.00000,-1.00000,-1.00000]
 

提示：

1 <= equations.length <= 20
equations[i].length == 2
1 <= equations[i][0].length, equations[i][1].length <= 5
values.length == equations.length
0.0 < values[i] <= 20.0
1 <= queries.length <= 20
queries[i].length == 2
1 <= queries[i][0].length, queries[i][1].length <= 5
equations[i][0], equations[i][1], queries[i][0], queries[i][1] 由小写英文字母与数字组成

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/evaluate-division
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

基本思路：若a->b->c,即a/b=2,b/c=3,那么a/c=a/b*(b/c)=6,但是a/c=-1,动态连通问题，故可以使用并查集求解。

• 求解:对于连通图上的任意节点a和b，a/b=(a/root)/(b/root);若不在同一个连通图上时，a/b=-1;
• 构建连通图时，当节点a,b分别属于不同的两个连通图时，需要合并两个连通图并更新权值，假设根节点分别是root_a,root_b，w[root_a]=v*w[b]/w[a];
• 当使用find_root时，递归的更新权值。

    unordered_map<string,string> parent;
    unordered_map<string,double> weight;


    void initUF(vector<vector<string>> &equations){
        for(auto &eq:equations){
            if(parent.find(eq[0])==parent.end()){
                parent[eq[0]]=eq[0];
                weight[eq[0]]=1.0;
            }
            if(parent.find(eq[1])==parent.end()){
                parent[eq[1]]=eq[1];
                weight[eq[1]]=1.0;               
            }
        }
    }
    string find_root(string &a){
        if(a!=parent[a]){
            string root=find_root(parent[a]);
            weight[a]*=weight[parent[a]];  //若a->b->c,递归式更新权值,先更新w[b],再w[a];
            parent[a]=root; //若a->b->c,其parent[x]=c;
        }
        return parent[a];
    }
    void union_Eq(string &a,string &b,double v){
        string root_a=find_root(a);
        string root_b=find_root(b);
        if(root_a==root_b)
            return ;
        parent[root_a]=root_b;  //a/b=(a/root_b)/(b/root_b)
        weight[root_a]=v*weight[b]/weight[a];
        /**
            设weight[root_a]=root_a/root_b=t
            a/b=v  =>(a/root_a)*(root_a/root_b)/(b/root_b)=v 
                   => w[a]*t/w[b]=v
                   => t=v*w[b]/w[a]
                   注:此时w[a]还没更新，等待find_root(a)更新



        **/
        
    }
    vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {
        int len=equations.size();
        vector<double> ans;
        initUF(equations);
        for(int i=0;i<len;i++){
            union_Eq(equations[i][0],equations[i][1],values[i]);
        }



        for(int i=0;i<queries.size();i++){
            if(parent.find(queries[i][0])==parent.end()||parent.find(queries[i][1])==parent.end())
                ans.push_back(-1.0);
            else{
                string root_a=find_root(queries[i][0]);
                string root_b=find_root(queries[i][1]);
                if(root_a!=root_b){
                    ans.push_back(-1.0);
                }
                else{
                    ans.push_back(weight[queries[i][0]]/weight[queries[i][1]]);
                }
            }
        }

        return ans;

    }