Find the Lexicographically Smallest Valid Sequence

Find the Lexicographically Smallest Valid Sequence - Problem

You are given two strings word1 and word2.

A string x is called almost equal to y if you can change at most one character in x to make it identical to y.

A sequence of indices seq is called valid if:

The indices are sorted in ascending order.
Concatenating the characters at these indices in word1 in the same order results in a string that is almost equal to word2.

Return an array of size word2.length representing the lexicographically smallest valid sequence of indices. If no such sequence of indices exists, return an empty array.

Note that the answer must represent the lexicographically smallest array, not the corresponding string formed by those indices.

Input & Output

Example 1 — Basic Case

$ Input: word1 = "vsum", word2 = "um"

› Output: [2,3]

💡 Note: We can pick indices [2,3] to get "um" which exactly matches word2. This is the lexicographically smallest valid sequence.

Example 2 — One Character Difference

$ Input: word1 = "hello", word2 = "eo"

› Output: [1,4]

💡 Note: Pick indices [1,4] to get "eo" which exactly matches word2. Other combinations like [0,4] would give "ho" requiring one change.

Example 3 — No Valid Sequence

$ Input: word1 = "abc", word2 = "def"

› Output: []

💡 Note: No sequence of indices can form a string almost equal to "def" since we'd need to change all characters.

Constraints

1 ≤ word1.length, word2.length ≤ 3 × 10³
word1 and word2 consist only of lowercase English letters.

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to use a greedy approach with lookahead to select the lexicographically smallest valid sequence. We greedily pick the smallest possible index at each step while ensuring the remaining characters can still be matched with at most one total mismatch. Best approach is Greedy with Lookahead. Time: O(n × m), Space: O(1)

Common Approaches

✓ Math

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

Brute Force with Backtracking

⏱️ Time: O(n^m × m) Space: O(m)

Generate all possible sequences of indices from word1 and check if the resulting string is almost equal to word2. Return the lexicographically smallest valid sequence.

Greedy with Lookahead

⏱️ Time: O(n × m) Space: O(1)

Use a greedy approach to select the smallest possible index at each step while ensuring the remaining characters can still be matched. Use lookahead to verify feasibility.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static char word1[1001];
static char word2[1001];
static int result[1001];
static int current_seq[1001];
static int result_size = 0;

int is_almost_equal(char* s1, char* s2, int len) {
    int diff_count = 0;
    for (int i = 0; i < len; i++) {
        if (s1[i] != s2[i]) {
            diff_count++;
            if (diff_count > 1) return 0;
        }
    }
    return 1;
}

int backtrack(int pos, int word1_idx, int m, int n) {
    if (pos == m) {
        // Form the word and check if almost equal
        char word_formed[1001];
        for (int i = 0; i < m; i++) {
            word_formed[i] = word1[current_seq[i]];
        }
        
        if (is_almost_equal(word_formed, word2, m)) {
            // Copy current_seq to result
            result_size = m;
            for (int i = 0; i < m; i++) {
                result[i] = current_seq[i];
            }
            return 1;
        }
        return 0;
    }
    
    for (int i = word1_idx; i < n; i++) {
        current_seq[pos] = i;
        if (backtrack(pos + 1, i + 1, m, n)) {
            return 1;
        }
    }
    
    return 0;
}

int main() {
    // Read input
    fgets(word1, sizeof(word1), stdin);
    fgets(word2, sizeof(word2), stdin);
    
    // Remove newlines
    word1[strcspn(word1, "\n")] = 0;
    word2[strcspn(word2, "\n")] = 0;
    
    int n = strlen(word1);
    int m = strlen(word2);
    
    result_size = 0;
    
    if (backtrack(0, 0, m, n)) {
        // Print result as JSON array
        printf("[");
        for (int i = 0; i < result_size; i++) {
            if (i > 0) printf(",");
            printf("%d", result[i]);
        }
        printf("]\n");
    } else {
        printf("[]\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

856 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