Restore the Array From Adjacent Pairs

Restore the Array From Adjacent Pairs - Problem

There is an integer array nums that consists of n unique elements, but you have forgotten it. However, you do remember every pair of adjacent elements in nums.

You are given a 2D integer array adjacentPairs of size n - 1 where each adjacentPairs[i] = [ui, vi] indicates that the elements ui and vi are adjacent in nums.

It is guaranteed that every adjacent pair of elements nums[i] and nums[i+1] will exist in adjacentPairs, either as [nums[i], nums[i+1]] or [nums[i+1], nums[i]]. The pairs can appear in any order.

Return the original array nums. If there are multiple solutions, return any of them.

Input & Output

Example 1 — Basic Linear Chain

$ Input: adjacentPairs = [[2,1],[1,3]]

› Output: [2,1,3]

💡 Note: The pairs tell us 2 connects to 1, and 1 connects to 3. Since 2 and 3 each have only one neighbor, they are endpoints. Starting from endpoint 2: 2→1→3.

Example 2 — Longer Chain

$ Input: adjacentPairs = [[4,2],[1,4],[3,1]]

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

💡 Note: Build graph: 4↔2, 4↔1, 1↔3. Endpoints are 2 and 3 (one neighbor each). Starting from 2: 2→4→1→3.

Example 3 — Two Elements

$ Input: adjacentPairs = [[100,200]]

› Output: [100,200]

💡 Note: Minimum case: only one pair means two adjacent elements. Both are endpoints, so either [100,200] or [200,100] is valid.

Constraints

nums.length == n
adjacentPairs.length == n - 1
2 ≤ n ≤ 10⁵
-10⁵ ≤ nums[i], ui, vi ≤ 10⁵
There exists some nums that has adjacentPairs as its pairs

Visualization

Tap to expand

Asked in

f Facebook 15 G Google 12 a Amazon 8

The key insight is that this forms a linear chain where endpoints have exactly one neighbor while middle elements have two. Build an adjacency map from the pairs, find any endpoint (node with one connection), then traverse the chain. Best approach uses hash map with linear traversal - 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 unique numbers and verify if each arrangement produces the given adjacent pairs. This is extremely inefficient but conceptually simple.

DFS - Depth First Search

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

Build adjacency graph and use depth-first search to traverse the linear chain. Start from an endpoint and recursively visit unvisited neighbors until we reconstruct the entire array.

Hash Map - Build Adjacency Graph

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

Create a hash map where each number maps to its neighbors. Find an endpoint (number with only one neighbor) and traverse the chain by following connections while avoiding revisiting nodes.

Brute Force - Try All Permutations — Algorithm Steps

Extract all unique numbers from pairs
Generate all permutations
For each permutation, check if adjacent elements match given pairs
Return the valid permutation

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Numbers

Get unique numbers: [2,1,3]

Generate Permutations

Try [1,2,3], [1,3,2], [2,1,3]...

Verify

Check if adjacent pairs match given pairs

Code -

solution.c — C

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

#define MAX_NUMS 20
#define MAX_PAIRS 100

static int nums[MAX_NUMS];
static int perm[MAX_NUMS];
static int used[MAX_NUMS];
static int pairs[MAX_PAIRS][2];
static int result[MAX_NUMS];
static int found;
static int n, pairsSize;

int isPairValid(int a, int b) {
    for (int i = 0; i < pairsSize; i++) {
        if ((pairs[i][0] == a && pairs[i][1] == b) || 
            (pairs[i][0] == b && pairs[i][1] == a)) {
            return 1;
        }
    }
    return 0;
}

void generatePermutations(int pos) {
    if (found) return;
    
    if (pos == n) {
        // Check if this permutation is valid
        int valid = 1;
        for (int i = 0; i < n - 1; i++) {
            if (!isPairValid(perm[i], perm[i + 1])) {
                valid = 0;
                break;
            }
        }
        if (valid) {
            for (int i = 0; i < n; i++) {
                result[i] = perm[i];
            }
            found = 1;
        }
        return;
    }
    
    for (int i = 0; i < n; i++) {
        if (!used[i]) {
            used[i] = 1;
            perm[pos] = nums[i];
            generatePermutations(pos + 1);
            used[i] = 0;
            if (found) return;
        }
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse the input manually
    char *p = line;
    while (*p && *p != '[') p++; // Find first '['
    if (!*p) return 1;
    p++; // Skip '['
    
    pairsSize = 0;
    int numSet[1000] = {0}; // Use array as set, assuming nums are reasonable
    int minNum = 1000, maxNum = -1000;
    
    while (*p && *p != ']') {
        while (*p && *p != '[') p++; // Find inner '['
        if (!*p || *p != '[') break;
        p++; // Skip '['
        
        // Parse first number
        char *endp;
        int num1 = (int)strtol(p, &endp, 10);
        p = endp;
        
        while (*p && *p != ',' && *p != ']') p++;
        if (*p == ',') p++; // Skip ','
        
        // Parse second number
        int num2 = (int)strtol(p, &endp, 10);
        p = endp;
        
        while (*p && *p != ']') p++; // Find inner ']'
        if (*p == ']') p++; // Skip ']'
        while (*p && (*p == ',' || *p == ' ')) p++; // Skip comma and spaces
        
        pairs[pairsSize][0] = num1;
        pairs[pairsSize][1] = num2;
        pairsSize++;
        
        // Add to set
        if (num1 < minNum) minNum = num1;
        if (num1 > maxNum) maxNum = num1;
        if (num2 < minNum) minNum = num2;
        if (num2 > maxNum) maxNum = num2;
        numSet[num1 + 500] = 1;  // Offset to handle negative numbers
        numSet[num2 + 500] = 1;
    }
    
    // Extract unique numbers
    n = 0;
    for (int i = minNum; i <= maxNum; i++) {
        if (numSet[i + 500]) {
            nums[n++] = i;
        }
    }
    
    // Initialize
    found = 0;
    for (int i = 0; i < n; i++) {
        used[i] = 0;
    }
    
    // Generate permutations and find valid one
    generatePermutations(0);
    
    // Print result
    printf("[");
    for (int i = 0; i < n; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

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

⚠ Quadratic Growth

Space Complexity

O(n)

Store the current permutation and result array

⚡ Linearithmic Space

68.0K Views

Medium Frequency

~15 min Avg. Time

2.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