算法练习Day13[LeetCode]990. 等式方程的可满足性

990. 等式方程的可满足性

给定一个由表示变量之间关系的字符串方程组成的数组，每个字符串方程 equations[i] 的长度为 4，并采用两种不同的形式之一："a==b" 或 "a!=b"。在这里，a 和 b 是小写字母（不一定不同），表示单字母变量名。

只有当可以将整数分配给变量名，以便满足所有给定的方程时才返回 true，否则返回 false。 

 

示例 1：
输入：["a==b","b!=a"]
输出：false
解释：如果我们指定，a = 1 且 b = 1，那么可以满足第一个方程，但无法满足第二个方程。没有办法分配变量同时满足这两个方程。

示例 2：
输入：["b==a","a==b"]
输出：true
解释：我们可以指定 a = 1 且 b = 1 以满足满足这两个方程。

示例 3：
输入：["a==b","b==c","a==c"]
输出：true

示例 4：
输入：["a==b","b!=c","c==a"]
输出：false

示例 5：
输入：["c==c","b==d","x!=z"]
输出：true
 
 提示：
1. 1 <= equations.length <= 500
2. equations[i].length == 4
3. equations[i][0] 和 equations[i][3] 是小写字母
4. equations[i][1] 要么是 '='，要么是 '!'
5. equations[i][2] 是 '='

并查集是什么？
知乎大佬的解读写的很不错，简单易懂
对此题目来说，我们可以根据其相等性将26个字母分为多个集合：我们只关心连通性不关心距离，利用并查集来完成。
并查集数组下标代表该节点本身，值代表其指向的父节点，find()方法，获得根节点；union()方法，合并两个连通分量。

并查集的优化：
* 如果一个路径较长的话，会影响性能 —— 长路径毫无意义，一个集合(连通分量)的树形状没有实际意义，并查集的性质只有【连通性】而无关路径
* 在不断的扫描中，并查集一直在动态变化；其实在这个过程中，树的形状也可以同时动态变化
* 【并查集】的优化有两种：
* 1.路径压缩(隔代压缩和完全压缩)：动态减小树的高度，将长路径转化掉
* 2.按秩合并：根据树的高度进行合并(union)，即将高度低的树接到高度高的树上，防止高度的增长

class Solution {
    public boolean equationsPossible(String[] equations) {
        int[] parent = new int[26];
        for (int i = 0; i < 26; i++) {
            parent[i] = i;  初始化26个集合(26个根节点)
        }
        for (String str : equations) { 
        // 第一次扫描(只扫描等式) 建立并查集
            if (str.charAt(1) == '=') {
                int index1 = str.charAt(0) - 'a';
                int index2 = str.charAt(3) - 'a';
                union(parent, index1, index2);
                // 每个等式都有对应一次两个集合的连通操作
            }
        }
        for (String str : equations) {
        // 第二次扫描(只扫不等式) 检查不等式是否与并查集矛盾
            if (str.charAt(1) == '!') {
                int index1 = str.charAt(0) - 'a';
                int index2 = str.charAt(3) - 'a';
                // 不等式两端的节点，如果根节点相同(同一集合)，则矛盾
                if (find(parent, index1) == find(parent, index2)) {
                    return false;
                }
            }
        }
        return true;
    }

      // 合并两个连通分量 ：
    public void union(int[] parent, int index1, int index2) {
        parent[find(parent, index1)] = find(parent, index2);
        // 一个节点的根节点，成为另一个节点的根节点的子节点
    }

       // 寻找根节点 ：
    public int find(int[] parent, int index) {
    // 如果该节点不是根节点，就一直往上找(index = parent[index])直到找到根节点(满足index == parent[index])
        while (parent[index] != index) {
            parent[index] = parent[parent[index]];// 这步就是在动态的进行【路径压缩】：将其指向的父节点，设置为父节点的父节点 
            index = parent[index];
        }
        return index;
    }
}