Largest Divisible Subset - Practice Coding Problems

Largest Divisible Subset - Problem

You're given a set of distinct positive integers, and your task is to find the largest subset where every pair of elements has a special divisibility property.

Specifically, for any two elements a and b in your chosen subset, either:

a % b == 0 (a is divisible by b), OR
b % a == 0 (b is divisible by a)

This means that in a valid subset, you can always arrange the numbers in a sequence where each number divides the next one. For example, [1, 2, 4, 8] works because 1|2, 2|4, and 4|8.

Goal: Return the largest such subset. If multiple subsets have the same maximum size, return any one of them.

Example: Given [1, 2, 3, 4, 6], the answer could be [1, 2, 4] or [1, 2, 6] or [1, 3, 6] - all have length 3.

Input & Output

example_1.py — Basic Case

$ Input: [1, 2, 3, 4, 6]

› Output: [1, 2, 4] or [1, 2, 6] or [1, 3, 6]

💡 Note: Multiple valid subsets exist with length 3. In [1,2,4]: 1|2, 2|4. In [1,2,6]: 1|2, 2|6. In [1,3,6]: 1|3, 3|6.

example_2.py — Perfect Chain

$ Input: [1, 2, 4, 8]

› Output: [1, 2, 4, 8]

💡 Note: This forms a perfect divisible chain where each element divides the next: 1|2, 2|4, 4|8. The entire array is the answer.

example_3.py — Single Element

$ Input: [1]

› Output: [1]

💡 Note: With only one element, that element itself forms the largest (and only) divisible subset.

Visualization

Tap to expand

Understanding the Visualization

Sort the Blocks

Arrange all blocks by size to make stacking decisions easier

Try Each Position

For each block, find the tallest valid tower it can extend

Build the Tower

Use the best combination to build the tallest possible tower

Key Takeaway

🎯 Key Insight: The secret is recognizing that after sorting, any valid divisible subset forms a chain where smaller numbers divide larger ones, making DP transitions straightforward.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n log n) for sorting + O(n²) for DP transitions

⚠ Quadratic Growth

Space Complexity

O(n)

Space for DP array, parent array, and result

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 2 × 10⁹
All integers in nums are distinct
You may return the answer in any order

Asked in

G Google 45 a Amazon 32 ⊞ Microsoft 28 f Meta 22

The optimal approach uses dynamic programming with sorting. First sort the array, then build a DP table where dp[i] represents the length of the longest divisible subset ending at index i. The key insight is that after sorting, if element a divides element b, then a < b, making the DP transition straightforward. Time complexity: O(n²), Space complexity: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Sorting	O(n²)	O(n)	Sort array and use DP to build longest divisible sequences
Brute Force (Check All Subsets)	O(2^n × n^2)	O(n)	Generate all possible subsets and check divisibility condition for each

Dynamic Programming with Sorting — Algorithm Steps

Sort the input array in ascending order
Create DP array where dp[i] = length of longest subset ending at i
For each element, check all previous elements that divide it
Update dp[i] and track parent pointers for reconstruction
Reconstruct the actual subset using parent pointers

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort input array: [1,2,4,8] to enable efficient checking

Initialize DP

Create dp[] array where dp[i] = length of longest subset ending at i

Fill DP Table

For each element, check all previous elements that divide it

Reconstruct Path

Use parent pointers to build the actual subset

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int* largestDivisibleSubset(int* nums, int numsSize, int* returnSize) {
    if (numsSize == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    qsort(nums, numsSize, sizeof(int), compare);
    
    // dp[i] = length of longest subset ending at i
    int* dp = (int*)malloc(numsSize * sizeof(int));
    int* parent = (int*)malloc(numsSize * sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        dp[i] = 1;
        parent[i] = -1;
    }
    
    int maxLength = 1;
    int maxIndex = 0;
    
    for (int i = 1; i < numsSize; i++) {
        for (int j = 0; j < i; j++) {
            if (nums[i] % nums[j] == 0 && dp[j] + 1 > dp[i]) {
                dp[i] = dp[j] + 1;
                parent[i] = j;
            }
        }
        
        if (dp[i] > maxLength) {
            maxLength = dp[i];
            maxIndex = i;
        }
    }
    
    // Reconstruct the subset
    int* result = (int*)malloc(maxLength * sizeof(int));
    int current = maxIndex;
    int index = maxLength - 1;
    
    while (current != -1) {
        result[index--] = nums[current];
        current = parent[current];
    }
    
    *returnSize = maxLength;
    free(dp);
    free(parent);
    return result;
}

int main() {
    int nums[20];
    int n = 0;
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    char* token = strtok(input, "[],");
    while (token != NULL && n < 20) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    int returnSize;
    int* result = largestDivisibleSubset(nums, n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n log n) for sorting + O(n²) for DP transitions

⚠ Quadratic Growth

Space Complexity

O(n)

Space for DP array, parent array, and result

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 2 × 10⁹
All integers in nums are distinct
You may return the answer in any order

89.3K Views

Medium-High Frequency

~25 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Sorting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler