每日一解 等式方程的可满足性(哈希表解答)

题目 等式方程的可满足性

给定一个由表示变量之间关系的字符串方程组成的数组，每个字符串方程 equations[i] 的长度为 4，并采用两种不同的形式之一：“a==b” 或 “a!=b”。在这里，a 和 b 是小写字母（不一定不同），表示单字母变量名。
只有当可以将整数分配给变量名，以便满足所有给定的方程时才返回 true，否则返回 false。

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

示例 2： 输入：[“a == b”,“b == c”,“a == c”] 输出：true

示例 3： 输入：[“a == b”,“b != c”,“c == a”] 输出：false

示例 4： 输入：[“c == c”,“b == d”,“x!=z”] 输出：true

提示：
1 <= equations.length <= 500
equations[i].length == 4
equations[i][0] 和 equations[i][3] 是小写字母
equations[i][1] 要么是 ‘=’，要么是 ‘!’
equations[i][2] 是 ‘=’

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/satisfiability-of-equality-equations

思路

题目其实相当的有意思，因为其实这是逻辑判断题目，看起来好像过往没做过什么类似的题目，也想不到哪些数据结构或者算法比较适合于这个题目（于是再次瞄了瞄官解）。原来和昨日的一道题很类似，采用图的思路，利用所有的==符号将字符联系起来，就会形成一个个连通图。检查!=符号是不是满足在图中不连通，就可以得到答案了。
举个简单的例子：
[“a == b”,“b != c”,“c == a”]
由其中的 == 号会将a，b，c放入同一个连通的图中。我们检查b和c的时候因为他们处在连通图里，那么不应当满足!=的条件，那么输出答案false。
个人的代码如下：

实现代码

class Solution {
public:
	bool equationsPossible(vector<string>& equations) {
		unordered_map<char, int> data;
		vector<vector<char>> datatoid;
		int number_of_hash = 0;
		for (int i = 0; i < equations.size(); i++) {
			if (equations[i][1] == '=') {
				char c = equations[i][0];
				char d = equations[i][3];
				if (data.find(c) == data.end() && data.find(d) == data.end()) {
					data.insert(pair<char, int>(c, number_of_hash));
					data.insert(pair<char, int>(d, number_of_hash));
					vector<char> a;
					a.push_back(c);
					a.push_back(d);
					datatoid.push_back(a);
					number_of_hash++;
					continue;
				}
				if (data.find(c) != data.end() && data.find(d) != data.end()) {
					if (data[c] != data[d]) {
						vector<char> n = datatoid[data[d]];
						int b = data[c];
						for (int i = 0; i < datatoid[b].size(); i++) {
							n.push_back(datatoid[b][i]);
							data.find(datatoid[b][i])->second = data[d];
						}
						datatoid[data[d]] = n;
					}
				}
				else if (data.find(c) == data.end()) {
					data.insert(pair<char, int>(c, data[d]));
					datatoid[data[d]].push_back(c);
				}
				else {
					data.insert(pair<char, int>(d, data[c]));
					datatoid[data[c]].push_back(d);
				}
			}
			else {
				if (equations[i][0] == equations[i][3]) {
					return false;
				}
			}
		}
		for (int i = 0; i < equations.size(); i++) {
			if (equations[i][1] == '!') {
				if (data.find(equations[i][0]) == data.end() || data.find(equations[i][3]) == data.end()) {
					continue;
				}
				if (data[equations[i][0]] == data[equations[i][3]]) {
					return false;
				}
			}
		}
		return true;
	}
};

代码实现的时候呢，没有类似官方解答那样去做一个图，然后在查找的时候采用广度优先搜索去找到答案。我直接选择维护一个数组和一个哈希表。在数组里每个元素相当于一个桶，桶里就是连成同一个连通图的元素。哈希表则存储这些元素分别位于哪个桶。
还是举例说明一下代码的思路：
输入为： [“b == e”,“d == d”,“b!=c”,“f == b”,“d == b”,“f!=f”]

输入"b == e"：
哈希表：

b	e
0	0

数组：

0	b, e

输入"d == d"：
哈希表：

b	e	d
0	0	1

数组：

0	b, e
1	d

输入"f == b"：
哈希表：

b	e	d	f
0	0	1	0

数组：

0	b, e, f
1	d

输入"b==d":
哈希表：

b	e	d	f
0	0	0	0

数组：

0	b, e, f, d
1	d

这样在建立哈希映射关系和桶内元素的时候花的时间会多一些，但查找答案的时候使用的是哈希表，可以直接在O(1)的时间内判断不等式是否合理。