OJ练习第189题——除法求值

除法求值

力扣链接：399. 除法求值

题目描述

示例

官解思路：并查集

并查集简介：

· 并查集(不相交集合)用于处理动态连通性问题，最典型的应用是求解「最小生成树」的Kruskal算法;

· 并查集支持**「查询(find) 」、「合并 (union) 」** 两个操作;

· 并查集只回答两个结点是不是在一个连通分量中(也就是所谓的连通性问题)，并不回答路径问题;

· 如果一个问题具有传递性质，可以考虑用并查集;

· 并查集最常见的一种设计思想是:把同在一个连通分量中的结点组织成一个树形结构(代表元法);

· 并查集使用**「路径压缩」与「按秩合并」**解决树的高度增加带来的「查询」性能消耗问题;

1、构建有向图

2、「统一变量」与「路径压缩」的关系

为了避免并查集所表示的树形结构高度过高，影响查询性能。在查询一个结点 a 的根结点同时，把结点 a 到根结点的沿途所有结点的父亲结点都指向根结点。

路径压缩前后，并查集所表示的两棵树形结构等价，路径压缩以后的树的高度为 2，查询性能最好。

并查集的「查询」操作会执行「路径压缩」，一边查询一边修改结点指向是并查集的特色。

class Solution {
    public double[] calcEquation(List<List<String>> equations, double[] values, List<List<String>> queries) {
        int equationsSzie = equations.size();
        UnionFind UnionFind = new UnionFind(2 * equationsSzie);
        //第1步，预处理，将变量的值与id进行映射，使得并查集的底层使用数组实现，方便编码
        Map<String, Integer> hashMap = new HashMap<>(2 * equationsSzie);
        int id = 0;
        for(int i = 0; i < equationsSzie; i++) {
            List<String> equation = equations.get(i);
            String var1 = equation.get(0);
            String var2 = equation.get(1);
            if(!hashMap.containsKey(var1)) {
                hashMap.put(var1, id);
                id++;
            }
            if(!hashMap.containsKey(var2)) {
                hashMap.put(var2, id);
                id++;
            }
            UnionFind.union(hashMap.get(var1), hashMap.get(var2), values[i]);
        }
        //第2步，做查询
        int queriesSize = queries.size();
        double[] res = new double[queriesSize];
        for(int i = 0; i < queriesSize; i++) {
            String var1 = queries.get(i).get(0);
            String var2 = queries.get(i).get(1);

            Integer id1 = hashMap.get(var1);
            Integer id2 = hashMap.get(var2);
            if(id1 == null || id2 == null) res[i] = -1.0d;
            else res[i] = UnionFind.isConnected(id1, id2);
        }
        return res;
    }
    private class UnionFind {
        private int[] parent;
        //指向父节点的权值
        private double[] weight;
        public UnionFind(int n) {
            this.parent = new int[n];
            this.weight = new double[n];
            for(int i = 0; i < n; i++) {
                parent[i] = i;
                weight[i] = 1.0d;
            }
        }
        public void union(int x, int y, double value) {
            int rootX = find(x);
            int rootY = find(y);
            if(rootX == rootY) return;
            parent[rootX] = rootY;
            weight[rootX] = weight[y] * value / weight[x];
        }
        //路径压缩
        public int find(int x) {
            if(x != parent[x]) {
                int origin = parent[x];
                parent[x] = find(parent[x]);
                weight[x] *= weight[origin];
            }
            return parent[x];
        }
        public double isConnected(int x, int y) {
            int rootX = find(x);
            int rootY = find(y);
            if(rootX == rootY) return weight[x] / weight[y];
            else return -1.0d;
        }
    }
    
}