leetcode：952. 按公因数计算最大组件大小

题目来源

• leetcode：952. 按公因数计算最大组件大小

题目描述

class Solution {
public:
    int largestComponentSize(vector<int>& nums) {

    }
};

题目解析

分析数据

• 从下面知道，时间复杂度最多O(N * logN)
  
• 从下面知道，数据范围比较大&&数值不重复

分析题意

数值中的每个数通过其因子与其他数产生连接，这种连接具有传递性，所以用并查集

最终返回并查集最大的那棵树的有几个节点

暴力（超时）

算法

• 有N个元素，那么构建N个单独的小集合
• 然后枚举每一个组合：
  • 枚举1位置作为开始，然后看2、3、4、…N位置的数，求它们与1位置公因数，如果有除1之外的公因数，那么合并
  • 枚举2位置作为开始，然后看3、4、…N位置的数，求它们与1位置公因数，如果有除1之外的公因数，那么合并
  • …
• 最终返回并查集最大的那棵树的重量

怎么求两个数的公因数

• 凡是公因数，都用下面的递归方法求解

	// a，比都必须是整数，不能有任何一个等于0
	// 整数不超过32位，哪怕是long也搞不了几次，可以认为是O(1)
	int gcd(int a, int b){
        return b == 0 ? a : gcd(b, a % b);
    }

实现

class Solution {
    class UnionFind{
    private:
        // 记录连通分量
        int cnt;
        // 节点 x 的节点是 parent[x]
        std::vector<int> parent;
        // 新增⼀个数组记录树的“重量”
        std::vector<int> weight;
    public:
        /* 构造函数， n 为图的节点总数 */
        explicit UnionFind(int n){
            // ⼀开始互不连通, ⽗节点指针初始指向⾃⼰
            this->cnt = n;
            parent.resize(n);
            weight.resize(n);
            for (int i = 0; i < n; ++i) {
                parent[i] = i;
                weight[i] = 1;
            }
        }

        int maxSize() {
            int ans = 0;
            for (int size : weight) {
                ans = std::max(ans, size);
            }
            return ans;
        }


        //返回当前的连通分量个数
        int count() const{
            return cnt;
        }


        // 将p和q相连
        void unionElements(int p, int q){
            int rootP = findRoot(p);
            int rootQ = findRoot(q);
            if(rootP == rootQ){
                return;
            }

            // ⼩树接到⼤树下⾯， 较平衡
            if(weight[rootP] > weight[rootQ]){
                parent[rootQ] = rootP;
                weight[rootP] += weight[rootQ];
            }else{
                parent[rootP] = rootQ;
                weight[rootQ] += weight[rootP];
            }
            parent[rootP] = rootQ;
            --cnt;
        }

        // 判断p和q是否连通
        bool isConnected(int p, int q){
            int rootP = findRoot(p);
            int rootQ = findRoot(q);
            return rootQ == rootP;
        }

    private:
        int findParent(int n){
            return parent[n];
        }

        // 返回某个节点 x 的根节点
        int findRoot(int x){
            // 根节点的 parent[x] == x
            while (parent[x] != x){
                // 进行路径压缩
                parent[x] = parent[parent[x]];
                x = parent[x];
            }
            return x;
        }
    };


    // O(1)
    // m,n 要是正数，不能有任何一个等于0
    int gcd(int a, int b){
        return b == 0 ? a : gcd(b, a % b);
    }


public:
    int largestComponentSize(vector<int>& nums) {
        int N = nums.size();
        UnionFind set(N);
        for (int i = 0; i < N; ++i) {
            for (int j = i + 1; j < N; ++j) {
                if(gcd(nums[i], nums[j]) != 1){
                    set.unionElements(i, j);
                }
            }
        }
        return set.maxSize();
    }

};

优化

思考

（1）什么叫做质因子

• 质因子：
  • 因子，又叫“因数”或“约数”，如果整数a能被整数b整除，那就有一个整数q，使得a=b * q,则b和q都称为a的一个因子.
    • $15=3\ast 5$，所以3和5都是15的因子；
    • $8=2\ast 4$，那么2和4就是8的因子。
  • 质数，又叫“素数”，在大于1的自然数中，仅有1和本身为自己的因子的数叫素数
• 255的因子有1、3、5、15、17、51、85、255。其中是质数的是1、3、5、17，所以它的质因子就是1、3、5、17

（2）怎么判断一个数是不是质数

• 所谓质数就是只能被1和它本身整数的数
• 要判断X是不是质数
  • O(X)的方法：检测2,3，…X-1跟X取余验证
  • O($\sqrt{X}$)的方法：也是检测2,3…跟X取余验证
    • 当发现$X$ % $2\ne 0$时，$\frac{X}{2}$往右就没有必要验证了
    • 当发现 $X$ % $3\ne 0$时，$\frac{X}{3}$往右就没有必要验证了
    • …
    • 当发现 $X$ % $\sqrt{X}\ne 0$时，$\frac{X}{\sqrt{X}}=\sqrt{X}$往右就没有必要验证了
  • 所以从2验证到$\sqrt{X}$就可以停止了，在往右就不用继续验证了

（3）怎么求X的所有质因子

• 理论上：
  • 1，X一定是质因子
  • 然后从2验证到X-1，看它是不是它的质因子
    • 验证是不是因子，如果是因子，然后验证是不是质数
• 求X所有质因子这件事，$\sqrt{X}$拿不下。比如17的质因子最大为17，所以要验证到17

（4）其实我们没有必要一定求出质因子，因为只要a和b如果有相同的因子，那么必然有相同的质因子

• 这样求一个数的所有因子，每次拿一对，就可以在$\sqrt{X}$拿下
• 设计算法：
  • 建立一张因子表，key为因子，value为索引（这个因子是由哪个因子）
  • 遍历数组，对于每一个数求每个数的因子，每次求一对
    • 如果因子之前出现过，就合并
    • 如果没有出现过，就新加入

class Solution {
    class UnionFind{
    private:
        // 记录连通分量
        int cnt;
        // 节点 x 的节点是 parent[x]
        std::vector<int> parent;
        // 新增⼀个数组记录树的“重量”
        std::vector<int> weight;
    public:
        /* 构造函数， n 为图的节点总数 */
        explicit UnionFind(int n){
            // ⼀开始互不连通, ⽗节点指针初始指向⾃⼰
            this->cnt = n;
            parent.resize(n);
            weight.resize(n);
            for (int i = 0; i < n; ++i) {
                parent[i] = i;
                weight[i] = 1;
            }
        }

        int maxSize() {
            int ans = 0;
            for (int size : weight) {
                ans = std::max(ans, size);
            }
            return ans;
        }


        //返回当前的连通分量个数
        int count() const{
            return cnt;
        }


        // 将p和q相连
        void unionElements(int p, int q){
            int rootP = findRoot(p);
            int rootQ = findRoot(q);
            if(rootP == rootQ){
                return;
            }

            // ⼩树接到⼤树下⾯， 较平衡
            if(weight[rootP] > weight[rootQ]){
                parent[rootQ] = rootP;
                weight[rootP] += weight[rootQ];
            }else{
                parent[rootP] = rootQ;
                weight[rootQ] += weight[rootP];
            }
            parent[rootP] = rootQ;
            --cnt;
        }

        // 判断p和q是否连通
        bool isConnected(int p, int q){
            int rootP = findRoot(p);
            int rootQ = findRoot(q);
            return rootQ == rootP;
        }

    private:
        int findParent(int n){
            return parent[n];
        }

        // 返回某个节点 x 的根节点
        int findRoot(int x){
            // 根节点的 parent[x] == x
            while (parent[x] != x){
                // 进行路径压缩
                parent[x] = parent[parent[x]];
                x = parent[x];
            }
            return x;
        }
    };




public:
    int largestComponentSize(vector<int>& nums) {
        int N = nums.size();
        UnionFind unionFind(N);// arr中，N个位置，在并查集初始时，每个位置自己是一个集合
        std::unordered_map<int, int> fatorsMap;//      key 某个因子   value 哪个位置拥有这个因子
        for (int i = 0; i < N; ++i) {
            int num = nums[i];
            // 求出根号N， -> limit
            int limit = (int ) std::sqrt(num);
            for (int j = 1; j <= limit; ++j) {
                if(num % j == 0){
                    if(j != 1){
                        if(!fatorsMap.count(j)){
                            fatorsMap[j] = i;
                        }else{
                            unionFind.unionElements(fatorsMap[j], i);
                        }
                    }
                    int other = num / j;
                    if(other != 1){
                        if(!fatorsMap.count(other)){
                            fatorsMap[other] = i;
                        }else{
                            unionFind.unionElements(fatorsMap[other], i);
                        }
                    }
                }
            }
        }
        return unionFind.maxSize();
    }
};

---

---

---

---

---

---