Introduction

In this blog post, we will explore how to solve the LeetCode problem "952" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

Problem Statement

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 1: Input: nums = [4,6,15,35] Output: 4 Example 2: Input: nums = [20,50,9,63] Output: 2 Example 3: Input: nums = [2,3,6,7,4,12,21,39] Output: 8 Constraints: 1 <= nums.length <= 2 * 104 1 <= nums[i] <= 105 All the values of nums are unique.

Explanation

Here's a breakdown of the solution approach, followed by the Python code:

• Prime Factorization & Union-Find: The core idea is to find the prime factors of each number in the input array. Then, use the Union-Find data structure to connect numbers that share prime factors.

• Efficient Union-Find: Employ path compression and rank optimization within the Union-Find implementation to ensure near-constant time complexity for union and find operations.

• Largest Component: After processing all numbers, iterate through the parents to count the size of each connected component, returning the maximum size encountered.

• Complexity: Time: O(N * sqrt(M) + N*alpha(N)), where N is the length of nums, M is the maximum value in nums, and alpha is the inverse Ackermann function. Space: O(M + N), where M is the largest number and N is the number of elements.

Code

    def largestComponentSize(nums):
    """
    Finds the size of the largest connected component in the graph.

    Args:
        nums: An integer array of unique positive integers.

    Returns:
        The size of the largest connected component in the graph.
    """

    def find(parent, i):
        if parent[i] == i:
            return i
        parent[i] = find(parent, parent[i])
        return parent[i]

    def union(parent, rank, x, y):
        xroot = find(parent, x)
        yroot = find(parent, y)

        if xroot != yroot:
            if rank[xroot] < rank[yroot]:
                parent[xroot] = yroot
            elif rank[xroot] > rank[yroot]:
                parent[yroot] = xroot
            else:
                parent[yroot] = xroot
                rank[xroot] += 1
            return True  # Indicate a union occurred
        return False # Indicate no union

    max_num = max(nums)
    parent = list(range(max_num + 1))
    rank = [0] * (max_num + 1)

    num_index_map = {}
    for num in nums:
        num_index_map[num] = num

    for num in nums:
        i = 2
        temp = num
        while i * i <= temp:
            if temp % i == 0:
                if i in num_index_map:
                    union(parent, rank, num, i)
                while temp % i == 0:
                    temp //= i
            i += 1
        if temp > 1:
            if temp in num_index_map:
                union(parent, rank, num, temp)

    component_sizes = {}
    max_size = 0
    for num in nums:
        root = find(parent, num)
        component_sizes[root] = component_sizes.get(root, 0) + 1
        max_size = max(max_size, component_sizes[root])

    return max_size