Lexicographically Smallest Beautiful String

Lexicographically Smallest Beautiful String - Problem

String Greedy Hard

A string is beautiful if:

It consists of the first k letters of the English lowercase alphabet.
It does not contain any substring of length 2 or more which is a palindrome.

You are given a beautiful string s of length n and a positive integer k.

Return the lexicographically smallest string of length n, which is larger than s and is beautiful. If there is no such string, return an empty string.

A string a is lexicographically larger than a string b (of the same length) if in the first position where a and b differ, a has a character strictly larger than the corresponding character in b.

For example, "abcd" is lexicographically larger than "abcc" because the first position they differ is at the fourth character, and d is greater than c.

Input & Output

Example 1 — Basic Increment

$ Input: s = "abcz", k = 4

› Output: "abda"

💡 Note: Cannot increment 'z' (invalid for k=4), backtrack and increment 'c' to 'd', then build smallest valid suffix avoiding palindromes.

Example 2 — Simple Case

$ Input: s = "abc", k = 4

› Output: "abd"

💡 Note: Can increment last character 'c' to 'd'. Result "abd" has no palindromic substrings and is beautiful.

Example 3 — No Solution

$ Input: s = "bbab", k = 2

› Output: ""

💡 Note: All possible increments lead to palindromes or exceed k=2 limit. No valid next beautiful string exists.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ k ≤ 4
s consists of the first k letters of the English lowercase alphabet
s is beautiful

Visualization

Tap to expand

Asked in

G Google 25 f Meta 18 Apple 12

The key insight is to work backwards from the rightmost position to find where we can increment a character, then greedily build the lexicographically smallest valid suffix. Best approach is greedy increment and fix. Time: O(n²), Space: O(n)

Common Approaches

✓ Backtracking

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

Frequency Count

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

Brute Force - Try All Next Strings

⏱️ Time: O(k^n * n²) Space: O(n)

Generate the next lexicographically larger string, check if it's beautiful, repeat until found or impossible. This involves checking every possible increment.

Greedy - Increment and Fix

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

Work from right to left to find the first position we can increment. Once incremented, build the lexicographically smallest valid suffix by avoiding palindromic patterns.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

char best[1000] = "";

int isValidSubsequence(const char* subseq, const char* s, int k) {
    int subseqLen = strlen(subseq);
    char* target = malloc(subseqLen * k + 1);
    target[0] = '\0';
    
    for (int i = 0; i < k; i++) {
        strcat(target, subseq);
    }
    
    int i = 0;
    int targetLen = strlen(target);
    int sLen = strlen(s);
    
    for (int j = 0; j < sLen; j++) {
        if (i < targetLen && s[j] == target[i]) {
            i++;
        }
        if (i == targetLen) {
            free(target);
            return 1;
        }
    }
    
    int result = (i == targetLen);
    free(target);
    return result;
}

void backtrack(const char* s, int k, int* validChars, int pos, char* current, int currentLen) {
    // Check if current subsequence can be repeated k times
    if (currentLen > 0 && isValidSubsequence(current, s, k)) {
        if (currentLen > strlen(best) || 
            (currentLen == strlen(best) && strcmp(current, best) > 0)) {
            strcpy(best, current);
        }
    }
    
    // Try adding characters from remaining positions in original string
    int sLen = strlen(s);
    for (int i = pos; i < sLen; i++) {
        if (validChars[(unsigned char)s[i]]) {
            current[currentLen] = s[i];
            current[currentLen + 1] = '\0';
            backtrack(s, k, validChars, i + 1, current, currentLen + 1);
            current[currentLen] = '\0';
        }
    }
}

char* solution(char* s, int k) {
    int freq[256] = {0};
    int sLen = strlen(s);
    
    // Count frequencies
    for (int i = 0; i < sLen; i++) {
        freq[(unsigned char)s[i]]++;
    }
    
    // Only consider characters that appear at least k times
    int validChars[256] = {0};
    for (int i = 0; i < 256; i++) {
        if (freq[i] >= k) {
            validChars[i] = 1;
        }
    }
    
    strcpy(best, "");
    char current[1000];
    current[0] = '\0';
    backtrack(s, k, validChars, 0, current, 0);
    
    char* result = malloc(strlen(best) + 1);
    strcpy(result, best);
    return result;
}

int main() {
    char s[1000];
    int k;
    
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    scanf("%d", &k);
    
    char* result = solution(s, k);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

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