Restore the Array From Adjacent Pairs - Practice Coding Problems

Restore the Array From Adjacent Pairs - Problem

Imagine you had a perfect sequence of unique numbers, but somehow it got scrambled! 😱 All you have left are clues about which numbers were neighbors in the original array.

You're given a 2D array adjacentPairs where each adjacentPairs[i] = [u, v] tells you that numbers u and v were sitting right next to each other in the original array. Your mission? Restore the original sequence!

🔍 The Challenge: The pairs can be given in any order, and each pair [u, v] could represent either u followed by v OR v followed by u in the original array.

Example: If adjacentPairs = [[2,1],[3,4],[3,2]], the original array could be [1,2,3,4] because:
• 1 and 2 are adjacent
• 2 and 3 are adjacent
• 3 and 4 are adjacent

Think of it like solving a jigsaw puzzle where you only know which pieces touch each other!

Input & Output

example_1.py — Basic Chain

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

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

💡 Note: The pairs tell us: 2↔1, 3↔4, 3↔2. Connecting these gives us the chain 1-2-3-4, so the original array is [1,2,3,4].

example_2.py — Reverse Order

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

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

💡 Note: Same pairs as example 1 but in different order. We can reconstruct as [4,3,2,1] (or [1,2,3,4]). Both are valid since we can start from either end.

example_3.py — Two Elements

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

› Output: [100,200]

💡 Note: With only one pair [100,200], the original array must be [100,200] or [200,100]. Both numbers are endpoints since each appears in only one pair.

Constraints

nums.length == n
adjacentPairs.length == n - 1
adjacentPairs[i].length == 2
-10⁵ ≤ adjacentPairs[i][0], adjacentPairs[i][1] ≤ 10⁵
There exists some nums that satisfies adjacentPairs
All elements in nums are unique

Visualization

Tap to expand

Endpoint Detection:Find nodes with degree 1🚶 Chain Walking:Follow connections while avoiding backtrack⚡ Efficiency:O(n) time, single traversal needed

Understanding the Visualization

Identify the Pieces

Each adjacent pair represents two chain links that were connected

Find the Starting Point

Look for a link with only one connection - this must be an endpoint

Follow the Chain

Starting from the endpoint, follow each connection to the next link

Rebuild Complete

Continue until you reach the other endpoint with no more connections

Key Takeaway

🎯 Key Insight: In any linear chain, exactly two nodes have degree 1 (the endpoints). Start from either endpoint and follow the unique path through the chain to reconstruct the original sequence efficiently in O(n) time.

Asked in

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

The optimal solution uses graph traversal with DFS to reconstruct the original array. Build an adjacency list from the pairs, find an endpoint (node with degree 1), then traverse the chain using depth-first search while tracking the parent to avoid backtracking. This achieves O(n) time and O(n) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Permutations)	O(n! × n)	O(n)	Generate all possible arrangements and check which one satisfies all adjacent pairs
Two-Pass Graph Traversal	O(n)	O(n)	Build adjacency graph first, then traverse from an endpoint to reconstruct the array
One-Pass DFS Traversal (Optimal)	O(n)	O(n)	Build graph and traverse simultaneously using DFS for optimal performance

Brute Force (Try All Permutations) — Algorithm Steps

Extract all unique numbers from the adjacent pairs
Generate all possible permutations of these numbers
For each permutation, check if consecutive elements form valid adjacent pairs
Return the first valid permutation found

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Numbers

Find all unique numbers from adjacent pairs

Generate Permutations

Create every possible ordering of the numbers

Validate Each

Check if consecutive elements form valid pairs

Return First Valid

Return the first arrangement that works

Code -

solution.c — C

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

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

bool isValidPermutation(int* nums, int n, int pairs[][2], int pairCount) {
    for (int i = 0; i < n - 1; i++) {
        bool found = false;
        for (int j = 0; j < pairCount; j++) {
            if ((pairs[j][0] == nums[i] && pairs[j][1] == nums[i+1]) ||
                (pairs[j][1] == nums[i] && pairs[j][0] == nums[i+1])) {
                found = true;
                break;
            }
        }
        if (!found) return false;
    }
    return true;
}

bool permute(int* nums, int start, int n, int pairs[][2], int pairCount, int* result) {
    if (start == n) {
        if (isValidPermutation(nums, n, pairs, pairCount)) {
            for (int i = 0; i < n; i++) {
                result[i] = nums[i];
            }
            return true;
        }
        return false;
    }
    
    for (int i = start; i < n; i++) {
        swap(&nums[start], &nums[i]);
        if (permute(nums, start + 1, n, pairs, pairCount, result)) {
            return true;
        }
        swap(&nums[start], &nums[i]);
    }
    return false;
}

int* restoreArray(int** adjacentPairs, int pairsSize, int* returnSize) {
    int nums[1000];
    bool seen[20001] = {false};
    int count = 0;
    
    // Extract unique numbers
    for (int i = 0; i < pairsSize; i++) {
        for (int j = 0; j < 2; j++) {
            int num = adjacentPairs[i][j] + 10000; // Handle negative numbers
            if (!seen[num]) {
                seen[num] = true;
                nums[count++] = adjacentPairs[i][j];
            }
        }
    }
    
    int* result = malloc(count * sizeof(int));
    *returnSize = count;
    
    int pairs[1000][2];
    for (int i = 0; i < pairsSize; i++) {
        pairs[i][0] = adjacentPairs[i][0];
        pairs[i][1] = adjacentPairs[i][1];
    }
    
    permute(nums, 0, count, pairs, pairsSize, result);
    return result;
}

int main() {
    int pairs[][2] = {{2,1},{3,4},{3,2}};
    int* pairPtrs[3];
    for (int i = 0; i < 3; i++) {
        pairPtrs[i] = pairs[i];
    }
    
    int returnSize;
    int* result = restoreArray(pairPtrs, 3, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

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

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing one permutation and the set of unique numbers

⚡ Linearithmic Space

89.0K Views

Medium Frequency

~15 min Avg. Time

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