PigyChan_LeetCode 547. 朋友圈

547. 朋友圈

难度中等

班上有 N 名学生。其中有些人是朋友，有些则不是。他们的友谊具有是传递性。如果已知 A 是 B 的朋友，B 是 C 的朋友，那么我们可以认为 A 也是 C 的朋友。所谓的朋友圈，是指所有朋友的集合。
给定一个 N * N 的矩阵 M，表示班级中学生之间的朋友关系。如果M[i][j] = 1，表示已知第 i 个和 j 个学生互为朋友关系，否则为不知道。你必须输出所有学生中的已知的朋友圈总数。

示例 1：

输入：
[[1,1,0],
[1,1,0],
[0,0,1]]
输出：2
解释：已知学生 0 和学生 1 互为朋友，他们在一个朋友圈。
第2个学生自己在一个朋友圈。所以返回 2 。
示例 2：

输入：
[[1,1,0],
[1,1,1],
[0,1,1]]
输出：1
解释：已知学生 0 和学生 1 互为朋友，学生 1 和学生 2 互为朋友，所以学生 0 和学生 2 也是朋友，所以他们三个在一个朋友圈，返回 1 。

提示：
*
1 <= N <= 200
*
M[i][i] == 1
*
M[i][j] == M[j][i]

思路1.0:

这个矩阵关于对角线对称,且处于对角线上的值都为1,所以我们只需要遍历上三角形即可.就这样我们得到了关系集合R,也有了节点集合U[0:n],并查集的老套路走起.

代码1.0(未通过):

  class Solution {
  public:
      vector<int> eqlClass;
      vector<int> eqlClassSize;
      int num;
      int findCircleNum(vector<vector<int>>& M) {
          int n = M.size();
          //初始化
          eqlClass.resize(n);
          for (int i = 0; i < n; ++i)
              eqlClass[i] = i;
          eqlClassSize.resize(n, 1);
          num = n;

          for (int i = 0; i < n - 1; ++i) {
              for (int j = i + 1; j < n; ++j) {
                  if (M[i][j] == 1) {
                      combine(i, j);
                  }
              }
          }
          return num;
      }
      int find(int value) {
          while (value != eqlClass[value])
              value = eqlClass[value];
          return value;
      }
      void combine(int valueA, int valueB) {
          int rootA = find(valueA);
          int rootB = find(valueB);
          if (rootA == rootB) return;
          
          if (eqlClassSize[valueA] < eqlClassSize[valueB]) {
              eqlClass[rootA] = rootB;
              eqlClassSize[valueB] += eqlClassSize[valueA];
          }
          else {
              eqlClass[rootB] = rootA;
              eqlClassSize[valueA] += eqlClassSize[valueB];
          }
          --num;
      }
  };

why???

代码2.0

  class Solution {
  public:
      vector<int> eqlClass;


      int findCircleNum(vector<vector<int>>& M) {
          int n = M.size();
          int rst = 0;
          //初始化
          eqlClass.resize(n);
          for (int i = 0; i < n; ++i)
              eqlClass[i] = i;


          for (int i = 0; i < n - 1; ++i) {
              for (int j = i + 1; j < n; ++j) {
                  if (M[i][j] == 1) {
                      combine(i, j);
                  }
              }
          }
          
          for (int i = 0; i < n; ++i) {
              if (i == eqlClass[i]) ++rst;
          }
          return rst;
      }


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


      void combine(int valueA, int valueB) {
          int rootA = find(valueA);
          int rootB = find(valueB);
          if (rootA != rootB)
              eqlClass[rootA] = rootB;


      }
  };

原因找到了,他娘的打错了几个字!!但意外收获是: 得到最终结果的方式,用最后遍历所有掌门节点要比从头到尾维护一个全局变量要好,运行时间变快了!??

代码2.1

  class Solution {
  public:
      vector<int> eqlClass;
      vector<int> eqlClassSize;
      int findCircleNum(vector<vector<int>>& M) {
          int n = M.size();
          //初始化
          eqlClass.resize(n);
          for (int i = 0; i < n; ++i)
              eqlClass[i] = i;
          eqlClassSize.resize(n, 1);


          for (int i = 0; i < n - 1; ++i) {
              for (int j = i + 1; j < n; ++j) {
                  if (M[i][j] == 1) {
                      combine(i, j);
                  }
              }
          }


          int rst=0;
          for (int i = 0; i < n; ++i) {
              if (i == eqlClass[i]) ++rst;
          }
          return rst;
      }
      int find(int value) {
          while (value != eqlClass[value])
              value = eqlClass[value];
          return value;
      }
      void combine(int valueA, int valueB) {
          int rootA = find(valueA);
          int rootB = find(valueB);
          if (rootA == rootB) return;
          
          if (eqlClassSize[valueA] < eqlClassSize[valueB]) {
              eqlClass[rootA] = rootB;
              eqlClassSize[valueB] += eqlClassSize[valueA];
          }
          else {
              eqlClass[rootB] = rootA;
              eqlClassSize[valueA] += eqlClassSize[valueB];
          }
      }
  };