Construct the Lexicographically Largest Valid Sequence

Construct the Lexicographically Largest Valid Sequence - Problem

Array Backtracking Medium

Construct the Lexicographically Largest Valid Sequence

You're tasked with creating a special sequence of numbers with very specific rules. Given an integer n, you need to construct a sequence where:

🔹 The number 1 appears exactly once
🔹 Each number from 2 to n appears exactly twice
🔹 For any number i (where i ≥ 2), the distance between its two occurrences must be exactly i

The distance between two positions in the sequence is the absolute difference of their indices. For example, if number 3 appears at positions 2 and 5, the distance is |5 - 2| = 3.

Your goal is to find the lexicographically largest sequence that satisfies all these constraints. A sequence A is lexicographically larger than sequence B if, at the first position where they differ, A has a larger number.

Example: For n=3, the sequence [3,1,2,3,2] is valid because:
- Number 1 appears once at position 1
- Number 2 appears at positions 2 and 4 (distance = 2)
- Number 3 appears at positions 0 and 3 (distance = 3)

Input & Output

example_1.py — Small case

$ Input: n = 3

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

💡 Note: For n=3: Number 1 appears once at position 1. Number 2 appears at positions 2 and 4 (distance = 2). Number 3 appears at positions 0 and 3 (distance = 3). This is the lexicographically largest valid sequence.

example_2.py — Minimal case

$ Input: n = 1

› Output: [1]

💡 Note: For n=1: Only number 1 exists, so the sequence is simply [1].

example_3.py — Medium case

$ Input: n = 4

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

💡 Note: For n=4: The sequence satisfies all distance constraints. Number 1 appears once, and each number from 2 to 4 appears twice with the correct distance between occurrences.

Visualization

Tap to expand

Understanding the Visualization

Start with Highest VIP

Try to seat the most important guest (number n) first

Place Couples

For couples, place both seats with exact distance requirement

Place Loner

Guest 1 gets a single seat wherever it fits

Backtrack if Stuck

If no arrangement works, try different positions

Key Takeaway

🎯 Key Insight: By trying to place the largest numbers first at each position, we naturally construct the lexicographically largest valid sequence while using backtracking to handle constraint violations efficiently.

Time & Space Complexity

Time Complexity

⏱️

O((2n-1)!)

We generate all permutations of 2n-1 elements (1 appears once, 2 to n appear twice)

✓ Linear Growth

Space Complexity

O(2n-1)

Space for storing the sequence and recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 20
The sequence length will be 2n - 1
It is guaranteed that a solution always exists

Asked in

G Google 42 a Amazon 28 f Meta 24 ⊞ Microsoft 18

The optimal solution uses backtracking to construct the sequence greedily. We place numbers from n down to 1 at each position to ensure lexicographical maximality. For each number ≥ 2, we place both occurrences with the correct distance, and backtrack if placement fails. This approach is much more efficient than generating all permutations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Permutations)	O((2n-1)!)	O(2n-1)	Generate all possible sequences and check validity
Backtracking (Optimal)	O(2^n)	O(n)	Use backtracking to construct sequence greedily from left to right

Brute Force (Generate All Permutations) — Algorithm Steps

Create a list with 1 appearing once and numbers 2 to n appearing twice
Generate all permutations of this list
For each permutation, check if distance constraints are satisfied
Keep track of the lexicographically largest valid sequence
Return the best sequence found

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Number List

Create list [1,2,2,3,3,...,n,n]

Generate Permutations

Generate all possible arrangements

Check Constraints

Verify distance constraints for each permutation

Track Best

Keep the lexicographically largest valid sequence

Code -

solution.c — C

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

bool isValid(int* seq, int len, int n) {
    for (int i = 2; i <= n; i++) {
        int positions[2], count = 0;
        for (int j = 0; j < len; j++) {
            if (seq[j] == i) {
                positions[count++] = j;
                if (count > 2) return false;
            }
        }
        if (count != 2 || abs(positions[1] - positions[0]) != i) {
            return false;
        }
    }
    return true;
}

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

bool isLexLarger(int* a, int* b, int len) {
    for (int i = 0; i < len; i++) {
        if (a[i] > b[i]) return true;
        if (a[i] < b[i]) return false;
    }
    return false;
}

void permute(int* nums, int start, int len, int n, int* best, bool* found) {
    if (start == len) {
        if (isValid(nums, len, n)) {
            if (!*found || isLexLarger(nums, best, len)) {
                for (int i = 0; i < len; i++) {
                    best[i] = nums[i];
                }
                *found = true;
            }
        }
        return;
    }
    for (int i = start; i < len; i++) {
        swap(&nums[start], &nums[i]);
        permute(nums, start + 1, len, n, best, found);
        swap(&nums[start], &nums[i]);
    }
}

int* constructDistancedSequence(int n) {
    int len = 2 * n - 1;
    int* nums = malloc(len * sizeof(int));
    int* best = malloc(len * sizeof(int));
    
    nums[0] = 1;
    int idx = 1;
    for (int i = 2; i <= n; i++) {
        nums[idx++] = i;
        nums[idx++] = i;
    }
    
    bool found = false;
    permute(nums, 0, len, n, best, &found);
    
    free(nums);
    return best;
}

int main() {
    int n;
    scanf("%d", &n);
    int* result = constructDistancedSequence(n);
    printf("[");
    for (int i = 0; i < 2 * n - 1; i++) {
        printf("%d", result[i]);
        if (i < 2 * n - 2) printf(",");
    }
    printf("]\n");
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((2n-1)!)

We generate all permutations of 2n-1 elements (1 appears once, 2 to n appear twice)

✓ Linear Growth

Space Complexity

O(2n-1)

Space for storing the sequence and recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 20
The sequence length will be 2n - 1
It is guaranteed that a solution always exists

28.2K Views

Medium Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler