Count the Number of K-Free Subsets - Practice Coding Problems

Count the Number of K-Free Subsets - Problem

Count the Number of K-Free Subsets

You're given an integer array nums containing distinct elements and an integer k. Your task is to count how many subsets are k-free.

A subset is called k-free if it contains no two elements whose absolute difference equals k. In other words, for any two elements a and b in a k-free subset, |a - b| ≠ k.

Important: The empty set is always considered a k-free subset.

Goal: Return the total number of k-free subsets of the given array.

Example: If nums = [2, 4, 6] and k = 2, then subsets like {2, 6} are k-free (since |2-6| = 4 ≠ 2), but {2, 4} is not k-free (since |2-4| = 2 = k).

Input & Output

example_1.py — Basic case

$ Input: {"nums": [4, 2, 5, 9, 10, 3], "k": 1}

› Output: 24

💡 Note: After sorting: [2,3,4,5,9,10]. Chain 1: [2,3,4,5] gives 8 ways (House Robber DP), Chain 2: [9,10] gives 3 ways. Total: 8 × 3 = 24.

example_2.py — No conflicts

$ Input: {"nums": [2, 7, 4], "k": 1}

› Output: 8

💡 Note: No two elements have difference of 1, so all elements are independent. Each can be included or excluded: 2^3 = 8 subsets total.

example_3.py — Single element

$ Input: {"nums": [1], "k": 1}

› Output: 2

💡 Note: Only one element, so we have 2 subsets: {} (empty) and {1}. Both are k-free since there are no pairs to violate the constraint.

Constraints

0 ≤ nums.length ≤ 20
All elements in nums are distinct
-10⁶ ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ 10⁶

Visualization

Tap to expand

Understanding the Visualization

Identify Conflict Chains

Elements that differ by k form chains - like people who conflict sitting next to each other

Apply House Robber Logic

In each chain, we can't pick adjacent elements - classic House Robber problem

Combine Independent Results

Different chains are independent, so multiply their results together

Key Takeaway

🎯 Key Insight: Elements differing by k form chains where we can't pick adjacent elements - this transforms the problem into multiple independent House Robber subproblems!

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

The optimal approach groups elements into chains where consecutive elements differ by k, then applies House Robber dynamic programming to each chain. Within each chain, we cannot select adjacent elements, leading to a Fibonacci-like recurrence: dp[i] = dp[i-1] + dp[i-2]. The final answer is the product of results from all independent chains.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsets)	O(n² × 2^n)	O(1)	Generate all possible subsets and check each one for k-free property
Dynamic Programming with Grouping	O(n log n)	O(n)	Group elements into chains where consecutive elements differ by k, then solve House Robber on each chain

Brute Force (Generate All Subsets) — Algorithm Steps

Generate all possible subsets (2^n total)
For each subset, check all pairs of elements
If any pair has |a - b| = k, mark subset as invalid
Count all valid subsets

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Use bit manipulation to generate all 2^n subsets

Check Each Subset

For each subset, verify no two elements differ by k

Count Valid Subsets

Increment counter for each k-free subset found

Code -

solution.c — C

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

int countKFreeSubsets(int* nums, int numsSize, int k) {
    int count = 0;
    
    // Generate all 2^n subsets
    for (int mask = 0; mask < (1 << numsSize); mask++) {
        int subset[20];
        int subsetSize = 0;
        
        // Build current subset
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                subset[subsetSize++] = nums[i];
            }
        }
        
        // Check if 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() {
    int nums[] = {4, 2, 5, 9, 10, 3};
    int k = 1;
    printf("%d\n", countKFreeSubsets(nums, 6, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × 2^n)

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

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for counting and checking

✓ Linear Space

34.2K Views

Medium Frequency

~25 min Avg. Time

1.5K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Generate All Subsets) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler