PigyChan_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：

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

输入：[“ab","bc”,“a==c”]
输出：true
示例 4：

输入：[“ab",“b!=c”,"ca”]
输出：false
示例 5：

输入：[“cc","bd”,“x!=z”]
输出：true

思路1.0:

并查集的套路,只不过这次的节点集和关系集要动态增长了,这使得我们的代码要做出一定的改变.另外出现了特殊关系 “!=”,对此我的策略是先遍历完所有的 “==”,回过头来看"!=",此时各个等价类都已构造完毕,检查两个节点是否在同一等价类中.
"总共就26个字母嗷!"

代码1.0:

  class Solution {
  public:
      vector<int> eqlClass;
      vector<int> eqlClassSZ;


      bool equationsPossible(vector<string>& equations) {
          //初始化
          eqlClass.resize(27, 0);
          eqlClassSZ.resize(27, 0);
          vector<int> unEquIdx;


          for (int i = 0; i < equations.size(); ++i) {


              int valueA = equations[i][0] - 'a' + 1;
              int valueB = equations[i][3] - 'a' + 1;
              //第一个节点进入,自立门派
              if (eqlClass[valueA] == 0) {
                  eqlClass[valueA] = valueA;
                  eqlClassSZ[valueA] = 1;
              }
              if (eqlClass[valueB] == 0) {
                  eqlClass[valueB] = valueB;
                  eqlClassSZ[valueB] = 1;
              }


              if (equations[i][1] == '!') {
                  unEquIdx.push_back(i);
                  continue;
              }
              if (valueA == valueB) continue;


              combine(valueA, valueB);
          }


          for (const auto& i : unEquIdx) {
              int valueA = equations[i][0] - 'a' + 1;
              int valueB = equations[i][3] - 'a' + 1;




              if (isSameClass(valueA, valueB))
                  return false;
          }
          return true;
      }


      int find(int value) {
          while (eqlClass[value] != value)
              value = eqlClass[value];
          return value;
      }


      void combine(int valueA, int valueB) {
          int rootA = find(valueA);
          int rootB = find(valueB);


          if (eqlClassSZ[rootA] < eqlClassSZ[rootB]) {
              eqlClass[rootA] = rootB;
              eqlClassSZ[rootB] += eqlClassSZ[rootA];
          }
          else {
              eqlClass[rootB] = rootA;
              eqlClassSZ[rootA] += eqlClassSZ[rootB];
          }
      }


      bool isSameClass(int valueA, int valueB) {
          int rootA = find(valueA);
          int rootB = find(valueB);


          return rootA == rootB;
      }
  };