Construct the Lexicographically Largest Valid Sequence

Construct the Lexicographically Largest Valid Sequence - Problem

Array Backtracking Medium

Given an integer n, find a sequence with elements in the range [1, n] that satisfies all of the following conditions:

The integer 1 occurs once in the sequence.
Each integer between 2 and n occurs twice in the sequence.
For every integer i between 2 and n, the distance between the two occurrences of i is exactly i.
The distance between two numbers on the sequence, a[i] and a[j], is the absolute difference of their indices, |j - i|.

Return the lexicographically largest sequence. It is guaranteed that under the given constraints, there is always a solution.

A sequence a is lexicographically larger than a sequence b (of the same length) if in the first position where a and b differ, sequence a has a number greater than the corresponding number in b. For example, [0,1,9,0] is lexicographically larger than [0,1,5,6] because the first position they differ is at the third number, and 9 is greater than 5.

Input & Output

Example 1 — Small Case

$ Input: n = 3

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

💡 Note: For n=3, we need sequence with 1 once, 2 twice, 3 twice. Distance between two 2's is |3-1|=2 ✓, distance between two 3's is |4-0|=4≠3 ✗. Correct answer: [3,1,2,3,2] where 2's are at positions 2,4 (distance 2) and 3's are at positions 0,3 (distance 3).

Example 2 — Minimum Case

$ Input: n = 1

› Output: [1]

💡 Note: For n=1, only need number 1 once. The sequence is simply [1].

Example 3 — Medium Case

$ Input: n = 4

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

💡 Note: For n=4: 1 occurs once, 2,3,4 occur twice each. All distance constraints satisfied: 2's at distance 2, 3's at distance 3, 4's at distance 4. This is the lexicographically largest valid sequence.

Constraints

1 ≤ n ≤ 20

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 12

The key insight is to use backtracking with greedy placement - try larger numbers first at each position to ensure lexicographically largest result. Best approach is backtracking with constraint checking. Time: O(n!), Space: O(n)

Common Approaches

✓ Prefix Sum

⏱️ Time: N/A Space: N/A

Backtracking with Greedy Placement

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

Start with an empty sequence and try to place numbers from largest to smallest at each position. For each position, attempt to place the largest possible number that doesn't violate constraints. Backtrack when no valid placement is possible.

Brute Force - Generate All Permutations

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

Generate every possible arrangement of the required numbers (1 once, 2 to n twice each), then check each arrangement to see if it satisfies the distance constraints. Return the lexicographically largest valid sequence.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int result[50];
int resultSize;
bool used[21];
int usedCount[21];

bool backtrack(int pos, int n, int totalSize) {
    if (pos == totalSize) {
        return true;
    }
    
    // Try numbers from n down to 1 for lexicographically largest
    for (int num = n; num >= 1; num--) {
        int maxUse = (num == 1) ? 1 : 2;
        
        if (usedCount[num] >= maxUse) {
            continue;
        }
        
        // If this is the second occurrence of num (and num > 1), check distance
        if (num > 1 && usedCount[num] == 1) {
            // Find first occurrence
            int firstPos = -1;
            for (int i = 0; i < pos; i++) {
                if (result[i] == num) {
                    firstPos = i;
                    break;
                }
            }
            
            if (firstPos != -1) {
                int distance = pos - firstPos;
                if (distance != num) {
                    continue;
                }
            }
        }
        
        // Place number
        result[pos] = num;
        usedCount[num]++;
        
        if (backtrack(pos + 1, n, totalSize)) {
            return true;
        }
        
        // Backtrack
        usedCount[num]--;
    }
    
    return false;
}

void solution(int n) {
    // Calculate total size: 1 appears once, 2..n appear twice
    int totalSize = 1 + 2 * (n - 1);
    if (n == 1) totalSize = 1;
    
    resultSize = totalSize;
    
    // Initialize arrays
    memset(used, false, sizeof(used));
    memset(usedCount, 0, sizeof(usedCount));
    
    backtrack(0, n, totalSize);
}

int main() {
    char line[100];
    fgets(line, sizeof(line), stdin);
    
    int n = atoi(line);
    
    solution(n);
    
    // Print result in JSON format
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

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