The Number of Beautiful Subsets - Practice Coding Problems

The Number of Beautiful Subsets - Problem

Array Hash Table Math Dynamic Programming Backtracking Sorting Combinatorics Medium

Imagine you're organizing a special art exhibition where certain paintings cannot be displayed together due to their contrasting styles. You have an array nums of positive integers representing different artwork IDs, and a positive integer k representing the "conflict threshold".

A subset of artworks is considered "beautiful" if it doesn't contain any two pieces whose ID numbers have an absolute difference equal to k. For example, if k=3, then artworks with IDs 5 and 8 cannot be in the same beautiful subset since |5-8| = 3.

Your goal is to count all possible non-empty beautiful subsets that can be formed from the given array. Remember, each subset represents a different way to curate your exhibition!

Example: With nums = [2,4,6] and k = 2, the beautiful subsets are: [2], [4], [6], [2,6] (note that [2,4] and [4,6] are not beautiful since their differences equal k=2).

Input & Output

example_1.py — Basic Case

$ Input: nums = [2,4,6], k = 2

› Output: 4

💡 Note: The beautiful subsets are: [2], [4], [6], [2,6]. Note that [2,4], [4,6], and [2,4,6] are not beautiful because they contain pairs with difference k=2.

example_2.py — Single Element

$ Input: nums = [1], k = 1

› Output: 1

💡 Note: Only one non-empty subset exists: [1], which is trivially beautiful since it contains no pairs.

example_3.py — No Valid Pairs

$ Input: nums = [4,2,5,9,10,3], k = 1

› Output: 23

💡 Note: Many consecutive numbers exist (2,3,4,5), creating conflicts. The algorithm must carefully count only non-conflicting combinations.

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

You have a collection of paintings with catalog numbers [2,4,6] and conflict rule k=2

Check Conflicts

Paintings with numbers differing by exactly 2 cannot be displayed together (2 conflicts with 4, 4 conflicts with 6)

Valid Exhibitions

Count all possible non-empty exhibitions: [2], [4], [6], [2,6] = 4 total

Key Takeaway

🎯 Key Insight: Use backtracking with conflict checking to efficiently explore only valid combinations, avoiding the exponential cost of generating all possible subsets.

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case still explores all subsets, but with early pruning it's much faster in practice

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and frequency map

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 20
1 ≤ nums[i], k ≤ 1000
All elements in nums are positive integers
The array may contain duplicate values

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal approach uses backtracking with pruning to efficiently explore the solution space. By maintaining a frequency map of the current subset and checking for conflicts (elements differing by k) before adding new elements, we can prune invalid branches early and avoid generating all 2^n subsets. This reduces the practical runtime significantly while maintaining the same worst-case complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking with Pruning (Optimal)	O(2^n)	O(n)	Use backtracking to build subsets incrementally, pruning invalid paths early

Backtracking with Pruning (Optimal) — Algorithm Steps

Use backtracking to explore all possible subsets
Maintain a frequency map of current subset elements
Before adding an element, check if num-k or num+k exist in current subset
If valid, add element and recurse; backtrack by removing element
Count all valid non-empty subsets found

Visualization

Tap to expand

Step-by-Step Walkthrough

Decision Point

At each element, decide whether to include it or not

Conflict Check

Before including, check if num±k exists in current subset

Prune & Backtrack

Skip invalid branches and backtrack when needed

Code -

solution.c — C

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

#define MAX_NUMS 20
#define MAX_VAL 1000

int freq[MAX_VAL + 1];
int freqCount = 0;

int backtrack(int* nums, int numsSize, int k, int index) {
    if (index == numsSize) {
        return freqCount > 0 ? 1 : 0;
    }
    
    // Option 1: Don't include current element
    int count = backtrack(nums, numsSize, k, index + 1);
    
    // Option 2: Include current element if valid
    int num = nums[index];
    int conflict1 = (num - k >= 0) ? freq[num - k] : 0;
    int conflict2 = (num + k <= MAX_VAL) ? freq[num + k] : 0;
    
    if (conflict1 == 0 && conflict2 == 0) {
        if (freq[num] == 0) freqCount++;
        freq[num]++;
        count += backtrack(nums, numsSize, k, index + 1);
        // Backtrack
        freq[num]--;
        if (freq[num] == 0) freqCount--;
    }
    
    return count;
}

int beautifulSubsets(int* nums, int numsSize, int k) {
    memset(freq, 0, sizeof(freq));
    freqCount = 0;
    return backtrack(nums, numsSize, k, 0);
}

int main() {
    int nums[] = {2, 4, 6};
    int k = 2;
    printf("%d\n", beautifulSubsets(nums, 3, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case still explores all subsets, but with early pruning it's much faster in practice

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and frequency map

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 20
1 ≤ nums[i], k ≤ 1000
All elements in nums are positive integers
The array may contain duplicate values

28.5K Views

Medium Frequency

~25 min Avg. Time

867 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

Backtracking with Pruning (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler