Combination Generator with Constraints - Problem

Given a list of N items and a number K, generate all possible combinations of exactly K items from the list.

However, there's a twist: you're also given a list of forbidden pairs - certain items that cannot appear together in the same combination.

For example, if items [1, 2] form a forbidden pair, then any combination containing both item 1 and item 2 should be excluded from the result.

Input:

items: Array of N distinct items (integers)
k: Number of items to select in each combination
forbidden: Array of forbidden pairs, where each pair is represented as [item1, item2]

Output: Return all valid combinations as a 2D array, where each sub-array contains exactly K items and no forbidden pairs appear together.

Input & Output

Example 1 — Basic Case with Forbidden Pairs

$ Input: items = [1,2,3,4], k = 3, forbidden = [[1,3]]

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

💡 Note: All 3-combinations are [1,2,3], [1,2,4], [1,3,4], [2,3,4]. We exclude [1,2,3] and [1,3,4] because they contain the forbidden pair [1,3].

Example 2 — Multiple Forbidden Pairs

$ Input: items = [1,2,3,4], k = 2, forbidden = [[1,2],[3,4]]

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

💡 Note: All 2-combinations are [1,2], [1,3], [1,4], [2,3], [2,4], [3,4]. We exclude [1,2] and [3,4] due to forbidden pairs.

Example 3 — No Valid Combinations

$ Input: items = [1,2], k = 2, forbidden = [[1,2]]

› Output: []

💡 Note: The only possible 2-combination is [1,2], but it's forbidden, so no valid combinations exist.

Constraints

1 ≤ items.length ≤ 20
1 ≤ k ≤ items.length
0 ≤ forbidden.length ≤ 50
forbidden[i].length = 2
All items are distinct

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 Apple 12

The key insight is to use backtracking to build combinations incrementally while checking constraints at each step, rather than generating all combinations first. The backtracking approach prunes invalid branches early, avoiding wasteful computation. Time: O(2^n), Space: O(k)

Common Approaches

✓ Backtracking with Constraint Checking

⏱️ Time: O(2^n) Space: O(k)

Use recursive backtracking to build combinations one item at a time. Before adding each item, check if it conflicts with items already in the current combination. This prunes invalid branches early.

Generate All, Then Filter

⏱️ Time: O(C(n,k) × k² × f) Space: O(C(n,k) × k)

First generate every possible combination of K items from the input list. Then check each combination against the forbidden pairs list to see if it contains any conflicting items.

Backtracking with Constraint Checking — Algorithm Steps

Start with empty combination and process items one by one
Before adding an item, check if it conflicts with current combination
If valid, add item and recurse; if not, skip to next item
When combination reaches size K, add to results

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Building

Begin with empty combination, try adding items

Check Before Adding

Test if new item conflicts with current items

Prune Early

Skip entire branches that violate constraints

Code -

solution.c — C

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

typedef struct {
    int** combinations;
    int count;
    int capacity;
} CombinationList;

void addCombination(CombinationList* list, int* combo, int k) {
    if (list->count >= list->capacity) {
        list->capacity *= 2;
        list->combinations = realloc(list->combinations, list->capacity * sizeof(int*));
    }
    
    list->combinations[list->count] = malloc(k * sizeof(int));
    for (int i = 0; i < k; i++) {
        list->combinations[list->count][i] = combo[i];
    }
    list->count++;
}

int isValidAddition(int* current, int currentSize, int newItem, int forbidden[][2], int forbiddenCount) {
    for (int i = 0; i < currentSize; i++) {
        for (int f = 0; f < forbiddenCount; f++) {
            if ((current[i] == forbidden[f][0] && newItem == forbidden[f][1]) ||
                (current[i] == forbidden[f][1] && newItem == forbidden[f][0])) {
                return 0;
            }
        }
    }
    return 1;
}

void backtrack(int* items, int n, int k, int start, int* current, int pos, 
              CombinationList* result, int forbidden[][2], int forbiddenCount) {
    if (pos == k) {
        addCombination(result, current, k);
        return;
    }
    
    for (int i = start; i < n; i++) {
        if (isValidAddition(current, pos, items[i], forbidden, forbiddenCount)) {
            current[pos] = items[i];
            backtrack(items, n, k, i + 1, current, pos + 1, result, forbidden, forbiddenCount);
        }
    }
}

CombinationList* solution(int* items, int n, int k, int forbidden[][2], int forbiddenCount) {
    CombinationList* result = malloc(sizeof(CombinationList));
    result->combinations = malloc(1000 * sizeof(int*));
    result->count = 0;
    result->capacity = 1000;
    
    int* current = malloc(k * sizeof(int));
    backtrack(items, n, k, 0, current, 0, result, forbidden, forbiddenCount);
    free(current);
    
    return result;
}

int main() {
    int items[100], n = 0, k;
    int forbidden[100][2], forbiddenCount = 0;
    
    // Parse input (simplified)
    char line[1000];
    fgets(line, sizeof(line), stdin);
    // Parse items array
    
    fgets(line, sizeof(line), stdin);
    k = atoi(line);
    
    fgets(line, sizeof(line), stdin);
    // Parse forbidden pairs
    
    CombinationList* result = solution(items, n, k, forbidden, forbiddenCount);
    
    // Print result
    printf("[");
    for (int i = 0; i < result->count; i++) {
        printf("[");
        for (int j = 0; j < k; j++) {
            printf("%d", result->combinations[i][j]);
            if (j < k - 1) printf(",");
        }
        printf("]");
        if (i < result->count - 1) printf(",");
        free(result->combinations[i]);
    }
    printf("]\n");
    
    free(result->combinations);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case with no constraints, explores all subsets of items

✓ Linear Growth

Space Complexity

O(k)

Recursion stack depth limited by combination size k

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Combination Generator with Constraints - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Backtracking with Constraint Checking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler