Divide Nodes Into The Maximum Number Of Groups - Leetcode Solution

Problem Statement:

Given a set of distinct positive integers, divide the set into as many groups as possible such that no two integers in the same group share a common factor other than 1.

Example 1:

Input: nums = [2,3,4,5,6] Output: 3 Explanation: We can divide the set into [2,3], [4,5], [6]. Example 2:

Input: nums = [2,3,6,7,9,10,11,12] Output: 4 Explanation: We can divide the set into [2,3], [6,7], [9,11], [10,12].

Constraints:

1 <= nums.length <= 1000 1 <= nums[i] <= 10^4 All elements in nums are distinct.

Solution:

The main idea behind this problem is to find the maximum number of groups that can be formed such that no two integers in a group share a common factor other than 1. We can do this by finding all the factors of each number in the given set of distinct positive integers.

To solve this problem, we can start by creating a list of all the factors for each number in the set. We can then iterate through all possible combinations of numbers to form groups and check whether the numbers in each group have any common factors other than 1.

If the numbers in a group have no common factors other than 1, we can increment our group count. We return the maximum group count we found.

Implementation:

We can start by creating a function to find the factors of a number:

def factors(n): """ Returns a set of all factors of n """ res = set() for i in range(1, int(n**(0.5))+1): if n % i == 0: res.add(i) res.add(n//i) return res

Next, we can create our main function to solve the problem:

def max_groups(nums): # Find factors for each number factors_dict = dict() for num in nums: factors_dict[num] = factors(num)

# Iterate through all combination of numbers to form groups
max_group_count = 0
for i in range(1, 2**len(nums)):
    group = set()
    for j in range(len(nums)):
        if i & (1 << j):
            group.add(nums[j])
    # Check if numbers in group have any common factors other than 1
    is_valid_group = True
    for num1 in group:
        for num2 in group:
            if num1 != num2 and factors_dict[num1].intersection(factors_dict[num2]):
                is_valid_group = False
                break
        if not is_valid_group:
            break
    if is_valid_group:
        max_group_count = max(max_group_count, len(group))

return max_group_count

Time Complexity Analysis:

In this solution, we first find all factors for each number in the set. This takes O(n * sqrt(max(num))) time, where n is the number of elements in the set and max(num) is the largest element in the set.

Next, we iterate through all possible combinations of numbers to form groups. There are 2^n possible combinations, where n is the number of elements in the set. For each possible combination, we check if the numbers in the group have any common factors other than 1. Checking for common factors takes O(sqrt(max(num))) time. So the total time complexity of the solution is O(n * 2^n * sqrt(max(num))) which is quite high for large inputs.

Space Complexity Analysis:

We use a dictionary to store all factors for each number in the set. The dictionary will have a maximum of n entries. Each factor set can have at most sqrt(max(num)) elements. So the total space complexity is O(n * sqrt(max(num))).

Conclusion:

In this problem, we learned how to divide a set of distinct positive integers into as many groups as possible such that no two integers in the same group share a common factor other than 1. We used a combination of finding all factors and checking for common factors to solve the problem. The time complexity of our solution is quite high for large inputs, but it works well for small inputs.

1