399. 除法求值

题目描述：

给你一个变量对数组 equations 和一个实数值数组 values 作为已知条件，其中 equations[i] = [Ai, Bi] 和 values[i] 共同表示等式 Ai / Bi = values[i] 。每个 Ai 或 Bi 是一个表示单个变量的字符串。

另有一些以数组 queries 表示的问题，其中 queries[j] = [Cj, Dj] 表示第 j 个问题，请你根据已知条件找出 Cj / Dj = ? 的结果作为答案。

返回 所有问题的答案 。如果存在某个无法确定的答案，则用 -1.0 替代这个答案。如果问题中出现了给定的已知条件中没有出现的字符串，也需要用 -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 <= 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 由小写英文字母与数字组成

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

分析：

        这道题完完全全不会，看了题解，并查集，是我之前没有听说过的概念。因此去查了查相关资料。

        其中这一篇讲的不错：

https://zhuanlan.zhihu.com/p/93647900/

         看了一圈下来，感觉并查集的思想就是把单独的元素划分为若干个不同的类，每个类中选择一个代表，由代表进行类中的计算以及和其他类的交互。

例如：

equations = [["a","b"],["b","c"],["bc","cd"]]

则a和b互通，因为b和c互通，因此a和c也是互通，a、b、c组成一类

另一方面bc和cd互通，因此bc和cd组成一类，与a、b、c组成的类不互通

因此，a、b、c之间可以进行计算，但是不能和bc与cd进行计算。

更详细的分析请见题解：

https://leetcode-cn.com/problems/evaluate-division/solution/chu-fa-qiu-zhi-by-leetcode-solution-8nxb/

代码如下：

class Solution {
public:
    // 查找某元素x
    int find(vector<int> &f,vector<double> &w,int x)
    {
        // 如果该元素不是根节点
        if(f[x]!=x)
        {
            // 查找该元素父亲的根节点
            int father=find(f,w,f[x]);
            // 更新w[x]
            // w[x]之前为当前元素与父节点的比值，更新之后为当前元素与根节点的比值
            w[x]=w[x]*w[f[x]];
            // 更新该元素的父节点为根节点
            f[x]=father;

        }
        // 返回该元素的根节点
        return f[x];
    }
    // 合并x和y
    void merge(vector<int> &f,vector<double> &w,int x,int y,double value)
    {
        // 找到x的根节点fx
        int fx=find(f,w,x);
        // 找到y的根节点fy
        int fy=find(f,w,y);
        // 使得根节点fx的父节点指向根节点fy 
        // 该步骤把两个不相通的区域打通
        f[fx]=fy;
        // 更新fx到fy的比值
        w[fx]=value*w[y]/w[x];
        
    }
    vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {
        // map用来把equations中的string映射成为数字
        unordered_map<string,int> map;
        // 字符串的个数，即映射的个数
        int nvars=0;
        // 把equations中出现的每个字符串映射为一个数字
        for(int i=0;i<equations.size();i++)
        {
            string va=equations[i][0];
            string vb=equations[i][1];
            if(map.find(va)==map.end())
            map[va]=nvars++;
            if(map.find(vb)==map.end())
            map[vb]=nvars++;
            
        }
        // f[x]代表x的父元素 初始情况下x的父节点为它本身
        vector<int> f(nvars);
        // w代表该元素的值与其父元素的值的比例 初始情况下为1.0（初始情况下x的父节点为它本身）
        vector<double> w(nvars,1.0);
        for(int i=0;i<nvars;i++)
        f[i]=i;
        // 合并equations中出现的节点
        for(int i=0;i<equations.size();i++)
        {
            int va=map[equations[i][0]];
            int vb=map[equations[i][1]];
            merge(f,w,va,vb,values[i]);
        }
        // res用来存储答案
        vector<double> res;
        // 遍历queries数组，计算每一个答案
        for(int i=0;i<queries.size();i++)
        {
            // 初始化本次答案为-1.0
            double result=-1.0;
            // 如果能在map中找到queries中的第一个和第二个元素，说明该元素之前出现过，计算即可
            if(map.find(queries[i][0])!=map.end()&&map.find(queries[i][1])!=map.end())
            {
                // ia和ib代表queries中的两个元素
                int ia=map[queries[i][0]];
                int ib=map[queries[i][1]];
                // fa和fb代表ia和ib的父元素（即他们所在区域的根节点）
                int fa=find(f,w,ia);
                int fb=find(f,w,ib);
                // 如果ia和ib在同一个区域，那么就可以计算他们之间的比值，否则的话，无法计算
                if(fa==fb)
                {
                    result=w[ia]/w[ib];
                }
            }
            
            res.push_back(result);

        }
        return res;
    }
  
};

tips：

1.unordered_map只能使用基本数据类型和string当作key，无法使用数组，结构体等类型当作key。