Count the Number of K-Free Subsets - Problem

You are given an integer array nums, which contains distinct elements and an integer k. A subset is called a k-Free subset if it contains no two elements with an absolute difference equal to k.

Notice that the empty set is a k-Free subset.

Return the number of k-Free subsets of nums.

A subset of an array is a selection of elements (possibly none) of the array.

Input & Output

Example 1 — Basic Case

$ Input: nums = [4,7,9], k = 3

› Output: 6

💡 Note: K-free subsets are: {}, {4}, {7}, {9}, {4,9}, {7,9}. Cannot include {4,7} or {4,7,9} because |4-7|=3=k.

Example 2 — No Conflicts

$ Input: nums = [2,5,8], k = 4

› Output: 8

💡 Note: No two elements differ by 4, so all 2³=8 subsets are k-free: {}, {2}, {5}, {8}, {2,5}, {2,8}, {5,8}, {2,5,8}.

Example 3 — Multiple Conflicts

$ Input: nums = [1,4,7,10], k = 3

› Output: 8

💡 Note: Conflicts: 1-4=3, 4-7=3, 7-10=3. Elements form a chain where adjacent elements can't coexist.

Constraints

1 ≤ nums.length ≤ 20
1 ≤ nums[i] ≤ 1000
0 ≤ k ≤ 1000
nums contains distinct elements

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22

The key insight is to recognize this as a variant of the House Robber problem after sorting. Elements that differ by exactly k cannot both be included. Best approach uses Dynamic Programming with grouping by remainder mod k. Time: O(n²), Space: O(n).

Common Approaches

✓ Brute Force - Generate All Subsets

⏱️ Time: O(n² × 2ⁿ) Space: O(1)

For each possible subset, check if any two elements have absolute difference equal to k. If not, count it as valid. Use bit manipulation to generate all subsets.

Dynamic Programming - Optimized

⏱️ Time: O(n²) Space: O(n)

Sort the array and use dynamic programming similar to House Robber problem. For each element, decide whether to include it based on conflicts with previous elements.

Sort and Group by Remainder

⏱️ Time: O(n log n + n × 2ᵍ) Space: O(n)

Numbers that conflict (differ by k) will be in consecutive positions when sorted by remainder mod k. Group numbers and apply combinatorics to count valid subsets.

Brute Force - Generate All Subsets — Algorithm Steps

Generate all 2^n possible subsets using bit manipulation
For each subset, check all pairs of elements
Count subset if no pair has absolute difference equal to k

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Use bit manipulation to create all 2^n subsets

Check Pairs

For each subset, verify no two elements differ by k

Count Valid

Count subsets that pass the k-free test

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int k) {
    int count = 0;
    
    // Generate all 2^n subsets using bit manipulation
    for (int mask = 0; mask < (1 << numsSize); mask++) {
        int subset[20];
        int subsetSize = 0;
        
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                subset[subsetSize++] = nums[i];
            }
        }
        
        // Check if this subset is k-free
        int isKFree = 1;
        for (int i = 0; i < subsetSize && isKFree; i++) {
            for (int j = i + 1; j < subsetSize; j++) {
                if (abs(subset[i] - subset[j]) == k) {
                    isKFree = 0;
                    break;
                }
            }
        }
        
        if (isKFree) {
            count++;
        }
    }
    
    return count;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[20];
    int numsSize = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, numsSize, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × 2ⁿ)

2^n subsets, each requiring O(n²) time to check all pairs

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

23.5K Views

Medium Frequency

~25 min Avg. Time

845 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

Count the Number of K-Free Subsets - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Generate All Subsets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler