[LeetCode]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] 是 '='

解題思路

將每一個變量看作圖中的一個節點，把相等的關係 == 看作是連接兩個節點的邊，那麼由於表示相等關係的等式方程具有傳遞性，即如果 a==b 和 b==c 成立，則 a==c 也成立。也就是說，所有相等的變量屬於同一個連通分量。因此，可以使用並查集來維護這種連通分量的關係。
1）首先遍歷所有的等式，構造並查集。同一個等式中的兩個變量屬於同一個連通分量，因此將兩個變量進行合併。
2）然後遍歷所有的不等式。同一個不等式中的兩個變量不能屬於同一個連通分量，因此對兩個變量分別查找其所在的連通分量，如果兩個變量在同一個連通分量中，則產生矛盾，返回 false。
3）如果遍歷完所有的不等式沒有發現矛盾，則返回 true。

代碼

class Solution {
    public boolean equationsPossible(String[] equations) {
        UnionFind unionfind = new UnionFind(26);
        // 如果是'=='號，則進行合併，放入同一個連通分量
        for(String equation : equations){
            if(equation.charAt(1) == '='){
                int index1 = equation.charAt(0) - 'a';
                int index2 = equation.charAt(3) - 'a';
                unionfind.union(index1, index2);
            }
        }
        for(String equation : equations){
            if(equation.charAt(1) == '!'){
                int index1 = equation.charAt(0) - 'a';
                int index2 = equation.charAt(3) - 'a';
                // 如果等式有矛盾，返回false
                if(unionfind.isConnected(index1, index2)){
                    return false;
                }
            }
        }
        // 如果遍歷完所有等式之後，也沒有發現矛盾，則返回true
        return true;
     
    }
    private class UnionFind{
        private int[] parent;
        public UnionFind(int n){
            parent = new int[n];
            for(int i=0; i<n; i++){
                parent[i] = i; // 初始化爲自己
            }
        }

        // 尋找最遠的根節點
        public int find(int x){
            while(x != parent[x]){
                parent[x] = parent[parent[x]]; // 路徑壓縮
                x = parent[x];
            }
            return x;
        }

        // 合併
        public void union(int x, int y){
            int rootX = find(x);
            int rootY = find(y);
            parent[rootX] = rootY;
        }

        // 查看是否在同一個連通分量
        public boolean isConnected(int x, int y){
            return find(x) == find(y);
        }
    }
}