【leetcode】952. Largest Component Size by Common Factor（Union find）

You are given an integer array of unique positive integers nums. Consider the following graph:

• There are nums.length nodes, labeled nums[0] to nums[nums.length - 1],
• There is an undirected edge between nums[i] and nums[j] if nums[i] and nums[j] share a common factor greater than 1.

Return the size of the largest connected component in the graph.

　　Example 2:

　　Input: nums = [20,50,9,63]
　　Output: 2
　　这道题的含义是，对于一串数字，如果两两之间存在相同的大于1的的公因子，则这两个数可以当作为一组，同时如果A与B有大于1的公因子，B与C有大于1的公因子，则A、B、C可以当作一组，此时长度就是3，
这道题虽然是求Graph的长度，但按照上述的分析来看，其实就是将数组元素分组，然后求同一类元素的个数，对于这种题目优先考虑使用并查集。
　　并查集讲解帖子，对于一个并查集，主要做两步，Union 以及find。一般最简单的并查集包含以下几个步骤：
1） 初始化
　　假如有编号为1, 2, 3, ..., n的n个元素，我们用一个数组fa[]来存储每个元素的父节点（因为每个元素有且只有一个父节点，所以这是可行的）。一开始，我们先将它们的父节点设为自己。

int fa[MAXN];
 void init(int n)
{
    for (int i = 1; i <= n; ++i)
        fa[i] = i;
}

　2）查询

　　用递归的写法实现对代表元素的查询：一层一层访问父节点，直至根节点（根节点的标志就是父节点是本身）。要判断两个元素是否属于同一个集合，只需要看它们的根节点是否相同即可。

int find(int x)
{
    if(fa[x] == x)
        return x;
    else
        return find(fa[x]);
}

　对于这个一般可以路径压缩

int find(int x)
{
    if(x == fa[x])
        return x;
    else{
        fa[x] = find(fa[x]);  //父节点设为根节点
        return fa[x];         //返回父节点
    }
}

　　以上代码常常简写为一行：

int find(int x)
{
    return x == fa[x] ? x : (fa[x] = find(fa[x]));
}

3）合并

       两个不同的元素置为相同的父节点。合并操作也是很简单的，先找到两个集合的代表元素，然后将前者的父节点设为后者即可。

inline void merge(int i, int j)
{
    fa[find(i)] = find(j);
}

4） 本题思路

　　按照上述并查集的构建思路，对于所有元素，初始化一个数组用于存储当前元素和哪些元素通过公因子构成一组，然后统计每一组的元素个数，返回最大的个数值。

class Solution {
public:
    int largestComponentSize(vector<int>& A) {
        int n = 0, mx = 0, res = 0;
        unordered_map<int, int> m;
        for (int num : A) mx = max(mx, num); //数组长度
        vector<int> root(mx + 1); //初始化union 数组
        for (int i = 1; i <= mx; ++i) root[i] = i; //开始每个元素的头节点都指向自己
        for (int num : A) {
            for (int d = sqrt(num); d >= 2; --d) { //寻找每个元素的公因子
                if (num % d == 0) {
                    root[find(root, num)] = root[find(root, d)];  //将公因子的父节点合并
                    root[find(root, num)] = root[find(root, num / d)];
                }
            }
        }
        for (int num : A) {
            res = max(res, ++m[find(root, num)]); //统计不同元素的相同父节点个数 作为最大长度
        }
        return res;
    }
    int find(vector<int>& root, int x) {
        return root[x] == x ? x : (root[x] = find(root, root[x])); //在查询每个节点的父节点时必须压缩路径
    }
};