990. 等式方程的可满足性（并查集）

最新推荐文章于 2024-10-20 17:09:42 发布

Lazy mode

最新推荐文章于 2024-10-20 17:09:42 发布

阅读量140

点赞数

分类专栏： LeeCode代码文章标签：字符串 java leetcode 并查集

本文链接：https://blog.csdn.net/Codeoh/article/details/112289795

版权

LeeCode代码专栏收录该内容

254 篇文章 1 订阅

订阅专栏

这篇博客介绍了如何利用并查集数据结构解决LeetCode上的990题——等式方程的可满足性。通过遍历等式，将相等的变量放入同一集合，然后检查不等式是否违反已建立的集合关系，从而判断方程组是否可满足。代码中展示了详细的实现过程。

摘要由CSDN通过智能技术生成

package com.heu.wsq.leetcode.bingchaji;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 990. 等式方程的可满足性
 * @author wsq
 * @date 2021/1/6
 * 给定一个由表示变量之间关系的字符串方程组成的数组，每个字符串方程 equations[i] 的长度为 4，并采用两种不同的形式之一："a==b" 或 "a!=b"。在这里，a 和 b 是小写字母（不一定不同），表示单字母变量名。
 * 只有当可以将整数分配给变量名，以便满足所有给定的方程时才返回 true，否则返回 false。 
 *
 * 示例 1：
 * 输入：["a==b","b!=a"]
 * 输出：false
 * 解释：如果我们指定，a = 1 且 b = 1，那么可以满足第一个方程，但无法满足第二个方程。没有办法分配变量同时满足这两个方程。
 *
 * 链接：https://leetcode-cn.com/problems/satisfiability-of-equality-equations
 */
public class EquationsPossible {
    public boolean equationsPossible(String[] equations) {
        List<String> equalList = new ArrayList<>();
        List<String> notequalList = new ArrayList<>();
        for (String s: equations){
            if (s.charAt(1) == '!'){
                notequalList.add(s);
            }else{
                equalList.add(s);
            }
        }
        UnionFind unionFind = new UnionFind(equalList.size() * 2);
        Map<Character, Integer> map = new HashMap<>();
        int id = 0;
        for (String s: equalList){
            char var1 = s.charAt(0);
            char var2 = s.charAt(3);
            if (!map.containsKey(var1)){
                map.put(var1, id);
                id++;
            }
            if (!map.containsKey(var2)){
                map.put(var2, id);
                id++;
            }
            unionFind.union(map.get(var1), map.get(var2));
        }
        for (String s: notequalList){
            char var1 = s.charAt(0);
            char var2 = s.charAt(3);
            if (var1 == var2){
                return false;
            }
            if (map.get(var1) == null || map.get(var2) == null){
                continue;
            }
            boolean connected = unionFind.isConnected(map.get(var1), map.get(var2));
            if (connected){
                return false;
            }
        }
        return true;
    }
    private class UnionFind{
        private int[] parent;

        public UnionFind(int n){
            this.parent = new int[n];
            for (int i = 0; i < n; i++){
                this.parent[i] = i;
            }
        }

        public void union(int x, int y){
            int rootX = find(x);
            int rootY = find(y);
            if (rootX == rootY){
                return;
            }
            parent[rootX] = rootY;
        }

        private int find(int x){
            int r = x;
            while (r != parent[r]){
                r = parent[r];
            }
            int k = x;
            while (k != r){
                int tmp = parent[k];
                parent[k] = r;
                k = tmp;
            }
            return r;
        }

        public boolean isConnected(int x, int y){
            int rootX = find(x);
            int rootY = find(y);
            return rootX == rootY;
        }
    }
}