并查集修炼

好久没写博客，考试周过去了力扣每日一题的日子又来了
今天的题可真是披着medium的羊皮的hard狼啊，第一次真的写并查集的算法题就是王炸
废话不多说，先上题

除法求值

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

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

返回 所有问题的答案 。如果存在某个无法确定的答案，则用 -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 由小写英文字母与数字组成

摁是看了三遍才看懂题目在说啥，一脸懵逼跑去看题解
并查集说白了就是算法书上的UNION-FIND算法，只是考试周的复习的时候这个算法就是一笔带过。现在深入了解之后发现一些规律
1.并查集的精髓在于路径压缩，就是在find一个结点的时候运用递归直接找这个节点所在的根结点，并将这个节点的父节点设置为这个根结点
2.并查集在UNION的时候可以是按秩合并，就是让更深的那个树的根结点作为另一个与它合并的根结点的父节点，有点绕口，简单来说就是谁高谁牛逼，我就跟你混，我的父亲就是你。但在这个题里没用到，看解答是直接合并的


但是在这个题里面，由于还要考虑每个节点之间的倍数关系，所以更加复杂，准确的说本题是带权值的并查集问题，所以有以下几个问题要解决
1.在路径压缩的时候，更新权值的问题
2.这个每个节点都是字符串，怎样处理？
上解答

class Solution {
public:
    int findf(vector<int>& f, vector<double>& w, int x) {
        if (f[x] != x) {
            int father = findf(f, w, f[x]);
            w[x] = w[x] * w[f[x]];//更新权值
            f[x] = father;//找到根结点做父节点（路径压缩）
        }
        return f[x];
    }

    void merge(vector<int>& f, vector<double>& w, int x, int y, double val) {
        int fx = findf(f, w, x);//x所在根结点
        int fy = findf(f, w, y);//y所在根结点
        f[fx] = fy;//x的根结点指向y的父节点
        w[fx] = val * w[y] / w[x];//修改x根结点的权值
    }

    vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {
        int nvars = 0;//存储equations中有多少个不同的字母
        unordered_map<string, int> variables;//把不相同的字符用不同的整型数来表示

        int n = equations.size();
        for (int i = 0; i < n; i++) {
            if (variables.find(equations[i][0]) == variables.end()) {
                variables[equations[i][0]] = nvars++;
            }
            if (variables.find(equations[i][1]) == variables.end()) {
                variables[equations[i][1]] = nvars++;
            }
        }
        vector<int> f(nvars);
        vector<double> w(nvars, 1.0);
        for (int i = 0; i < nvars; i++) {
            f[i] = i;//所有节点初始父亲为自己
        }

        for (int i = 0; i < n; i++) {
            int va = variables[equations[i][0]], vb = variables[equations[i][1]];
            merge(f, w, va, vb, values[i]);
        }
        vector<double> ret;
        for (const auto& q: queries) {
            double result = -1.0;
            if (variables.find(q[0]) != variables.end() && variables.find(q[1]) != variables.end()) {
                int ia = variables[q[0]], ib = variables[q[1]];
                int fa = findf(f, w, ia), fb = findf(f, w, ib);
                if (fa == fb) {
                    result = w[ia] / w[ib];
                }
            }
            ret.push_back(result);
        }
        return ret;
    }
};

解答中的几个亮点
1.在处理更新权值问题时，经过分析，在合并时要将当前字符串对的value值乘以串2权值与串1权值的比值：w[f[x]]=value*w[y]/w[x]，find路径压缩时将路径上的节点权值相乘：w[x] = w[x] * w[f[x]]
2.在处理问题2时，解答运用哈希表将每个字符用不同的整型数来表示，这样使得并查集的使用更加方便，并且也使得处理equations中没有的字符更加方便，如果表里面没有直接result=-1就行了。