Queue Reconstruction by Height

Queue Reconstruction by Height - Problem

You are given an array of people, people, which represents the attributes of some people in a queue (not necessarily in order). Each people[i] = [h_i, k_i] represents the i-th person of height h_i with exactly k_i other people in front who have a height greater than or equal to h_i.

Reconstruct and return the queue that is represented by the input array people. The returned queue should be formatted as an array queue, where queue[j] = [h_j, k_j] is the attributes of the j-th person in the queue (queue[0] is the person at the front of the queue).

Input & Output

Example 1 — Basic Queue Reconstruction

$ Input: people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]

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

💡 Note: Person [5,0] has 0 people ≥ 5 in front (correct). Person [7,0] has 0 people ≥ 7 in front (correct). Person [5,2] has 2 people ≥ 5 in front: [5,0] and [7,0] (correct). And so on for all positions.

Example 2 — Simple Case

$ Input: people = [[6,0],[5,0],[4,0],[3,2],[2,2],[1,4]]

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

💡 Note: Each person is placed to satisfy their k-constraint: [4,0] needs 0 people ≥4 in front, [5,0] needs 0 people ≥5 in front, etc.

Example 3 — Same Heights

$ Input: people = [[7,0],[7,1],[6,1]]

› Output: [[7,0],[6,1],[7,1]]

💡 Note: [7,0] goes first with 0 people ≥7 in front. [6,1] goes next with 1 person ≥6 in front ([7,0]). [7,1] goes last with 1 person ≥7 in front ([7,0]).

Constraints

1 ≤ people.length ≤ 2000
0 ≤ h_i ≤ 10⁶
0 ≤ k_i < people.length
It is guaranteed that the queue can be reconstructed

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 f Facebook 12 M Microsoft 10

The key insight is that taller people don't affect shorter people's count, so we can sort by height descending and insert each person at their k-th position. Best approach is Sort First with Time: O(n²), Space: O(n).

Common Approaches

✓ Brute Force - Try All Permutations

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

Try every possible permutation of the people array and for each arrangement, verify that every person has exactly k people of greater or equal height in front of them.

Sort by Height then Insert

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

Sort people in descending order of height (with ascending k as tiebreaker). Then insert each person into the result array at their k-th position. This works because taller people don't affect the count for shorter people.

Brute Force - Try All Permutations — Algorithm Steps

Generate all permutations of the people array
For each permutation, validate if it satisfies all constraints
Return the first valid arrangement found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible arrangements of people

Validate Each

Check if arrangement satisfies all k-constraints

Return Valid

Return the first valid arrangement found

Code -

solution.c — C

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

static int people[10][2];
static int arrangement[10][2];
static int used[10];
static int peopleSize;
static int found;
static int result[10][2];

int isValid(int arr[][2], int size) {
    for (int i = 0; i < size; i++) {
        int h = arr[i][0];
        int k = arr[i][1];
        int count = 0;
        for (int j = 0; j < i; j++) {
            if (arr[j][0] >= h) {
                count++;
            }
        }
        if (count != k) {
            return 0;
        }
    }
    return 1;
}

void generatePermutations(int currentSize) {
    if (found) return;
    
    if (currentSize == peopleSize) {
        if (isValid(arrangement, peopleSize)) {
            for (int i = 0; i < peopleSize; i++) {
                result[i][0] = arrangement[i][0];
                result[i][1] = arrangement[i][1];
            }
            found = 1;
        }
        return;
    }
    
    for (int i = 0; i < peopleSize; i++) {
        if (!used[i]) {
            used[i] = 1;
            arrangement[currentSize][0] = people[i][0];
            arrangement[currentSize][1] = people[i][1];
            generatePermutations(currentSize + 1);
            used[i] = 0;
        }
    }
}

int main() {
    char line[1000];
    if (!fgets(line, sizeof(line), stdin)) {
        return 1;
    }
    
    peopleSize = 0;
    found = 0;
    
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr) ptr++;
    
    while (*ptr && *ptr != ']') {
        while (*ptr && *ptr != '[') ptr++;
        if (*ptr) ptr++;
        
        char* endptr;
        people[peopleSize][0] = (int)strtol(ptr, &endptr, 10);
        ptr = endptr;
        
        while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
        if (*ptr == ',') ptr++;
        
        people[peopleSize][1] = (int)strtol(ptr, &endptr, 10);
        ptr = endptr;
        
        while (*ptr && *ptr != ']') ptr++;
        if (*ptr) ptr++;
        
        peopleSize++;
        
        while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
    }
    
    for (int i = 0; i < peopleSize; i++) {
        used[i] = 0;
    }
    
    generatePermutations(0);
    
    printf("[");
    for (int i = 0; i < peopleSize; i++) {
        printf("[%d,%d]", result[i][0], result[i][1]);
        if (i < peopleSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n²)

n! permutations, each requiring O(n²) validation time

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing one permutation at a time

⚡ Linearithmic Space

217.0K Views

Medium Frequency

~25 min Avg. Time

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