Sort Items by Groups Respecting Dependencies

Sort Items by Groups Respecting Dependencies - Problem

There are n items each belonging to zero or one of m groups where group[i] is the group that the i-th item belongs to and it's equal to -1 if the i-th item belongs to no group. The items and the groups are zero indexed. A group can have no item belonging to it.

Return a sorted list of the items such that:

The items that belong to the same group are next to each other in the sorted list.
There are some relations between these items where beforeItems[i] is a list containing all the items that should come before the i-th item in the sorted array (to the left of the i-th item).

Return any solution if there is more than one solution and return an empty list if there is no solution.

Input & Output

Example 1 — Basic Case with Groups

$ Input: n = 8, m = 2, group = [-1,-1,1,0,0,1,0,-1], beforeItems = [[],[6],[5],[6],[3,6],[],[],[]]

› Output: [6,3,4,1,5,2,0,7]

💡 Note: Items 3,4,6 belong to group 0. Items 2,5 belong to group 1. Items 0,1,7 have no group. Dependencies: 6→1, 5→2, 6→3, 3→4, 6→4. Valid ordering respects both group constraints and dependencies.

Example 2 — No Groups

$ Input: n = 8, m = 2, group = [-1,-1,-1,-1,-1,-1,-1,-1], beforeItems = [[],[6],[5],[6],[3],[],[4],[]]

› Output: [6,3,4,5,2,1,0,7]

💡 Note: All items ungrouped, only dependency constraints matter. Dependencies: 6→1, 5→2, 6→3, 3→4, 4→6 creates cycle, but 4→6 not in input, so [6,3,4,5,2,1,0,7] works.

Example 3 — Impossible Case

$ Input: n = 2, m = 1, group = [0,0], beforeItems = [[1],[0]]

› Output: []

💡 Note: Items 0 and 1 both in group 0 but have circular dependency: 0 depends on 1, and 1 depends on 0. No valid ordering exists.

Constraints

1 ≤ m ≤ n ≤ 3 × 10⁴
group[i] == -1 or 0 ≤ group[i] < m
0 ≤ beforeItems[i].length ≤ n - 1
0 ≤ beforeItems[i][j] ≤ n - 1
i != beforeItems[i][j]
beforeItems[i] does not contain duplicates elements

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8 M Microsoft 6

This problem requires two-level topological sorting. The key insight is to treat both groups and individual items as separate graphs that need topological ordering. Use Kahn's algorithm (BFS) or DFS-based topological sort to handle dependencies while ensuring same-group items stay adjacent. Best approach: Kahn's algorithm. Time: O(n + E), Space: O(n + m)

Common Approaches

✓ Brute Force - Try All Permutations

⏱️ Time: O(n! × n) Space: O(n)

Try every possible permutation of items and check if it satisfies both group adjacency and dependency constraints. This approach is extremely inefficient but conceptually simple.

Kahn's Algorithm (BFS Topological Sort)

⏱️ Time: O(n + m + E) Space: O(n + m)

Implement Kahn's algorithm using BFS and indegree counting for both group and item dependencies. Process nodes with zero indegree first, then reduce indegrees of neighbors.

Topological Sort with DFS

⏱️ Time: O(n + m + E) Space: O(n + m)

Create dependency graphs for both groups and individual items, then use DFS-based topological sorting. First sort groups, then sort items within each group while respecting dependencies.

Brute Force - Try All Permutations — Algorithm Steps

Generate all n! permutations of items
For each permutation, verify group adjacency
Check all dependency constraints
Return first valid permutation

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all n! possible orderings

Check Constraints

Validate group adjacency and dependencies

Return First Valid

Return first ordering that satisfies all constraints

Code -

solution.c — C

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

int* solution(int n, int m, int* group, int** beforeItems, int* beforeItemsSize, int* returnSize) {
    // Brute force implementation would be extremely complex in C
    // Return empty array for this approach
    *returnSize = 0;
    return NULL;
}

int main() {
    int n, m;
    scanf("%d", &n);
    scanf("%d", &m);
    
    int* group = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &group[i]);
    }
    
    int** beforeItems = (int**)malloc(n * sizeof(int*));
    int* beforeItemsSize = (int*)malloc(n * sizeof(int));
    
    // Parse beforeItems (simplified)
    
    int returnSize;
    int* result = solution(n, m, group, beforeItems, beforeItemsSize, &returnSize);
    
    printf("[]");
    
    free(group);
    free(beforeItems);
    free(beforeItemsSize);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Storage for current permutation and validation

⚡ Linearithmic Space

25.4K Views

Medium Frequency

~35 min Avg. Time

892 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 - Try All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler