Lexicographically Smallest Beautiful String

Lexicographically Smallest Beautiful String - Problem

String Greedy Hard

A beautiful string follows two critical rules:

It consists only of the first k letters of the English lowercase alphabet (a, b, c, etc.)
It contains no palindromic substrings of length 2 or more

Given a beautiful string s of length n and a positive integer k, your task is to find the lexicographically smallest string that is:

Exactly n characters long
Lexicographically larger than s
Also beautiful according to the rules above

If no such string exists, return an empty string.

Example: For s = "abcb" and k = 4, we need to find the next beautiful string using letters {a,b,c,d}. The answer would be "abdc" because it's the smallest string larger than "abcb" with no palindromic substrings.

Input & Output

example_1.py — Basic case

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

› Output: "abda"

💡 Note: The next beautiful string after "abcz" using letters {a,b,c,d}. We increment 'c' to 'd' and fill the last position with 'a' (avoiding palindromes with previous characters 'b' and 'd').

example_2.py — Cannot increment last character

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

› Output: "abd"

💡 Note: We can increment the last character 'c' to 'd' directly, giving us "abd" which is beautiful and lexicographically larger than "abc".

example_3.py — No solution exists

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

› Output: ""

💡 Note: Since we're using only letters {a,b,c,d} and "dcba" is already the lexicographically largest possible string with these constraints, no larger beautiful string exists.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ k ≤ 26
s consists of the first k letters of the English lowercase alphabet
s is guaranteed to be beautiful initially

Visualization

Tap to expand

Understanding the Visualization

Identify increment position

Find the rightmost character that can still be incremented (< 'a' + k - 1)

Increment the character

Move to the next letter in our allowed alphabet

Construct remaining optimally

Fill each subsequent position with the smallest letter that doesn't create palindromes

Key Takeaway

🎯 Key Insight: Work backwards to find the rightmost incrementable character, then greedily construct forward while avoiding palindromes with the previous 1-2 characters.

Asked in

G Google 45 f Facebook 32 a Amazon 28 ⊞ Microsoft 15

The optimal solution uses a greedy approach working backwards from the string's end. We find the rightmost character that can be incremented, increase it, then greedily fill the remaining positions while avoiding palindromic substrings by checking the previous 1-2 characters. This achieves O(n×k) time complexity without generating invalid intermediate strings.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Greedy Construction	O(n × k)	O(1)	Increment from the rightmost position and construct greedily to avoid palindromic substrings

Optimized Greedy Construction — Algorithm Steps

Start from the rightmost character and try to increment it
For each position, try characters from current+1 to k-th letter
After incrementing, greedily fill remaining positions
For each new character, avoid creating palindromes with previous 1-2 characters
Return the constructed string or empty if impossible

Visualization

Tap to expand

Step-by-Step Walkthrough

Find increment position

Start from the right and find first character that can be incremented

Increment character

Increase the character to the next available letter

Fill remaining positions

Greedily fill each remaining position avoiding palindromes

Code -

solution.c — C

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

char* smallestBeautifulString(char* s, int k) {
    static char result[1000];
    int n = strlen(s);
    strcpy(result, s);
    
    // Try to increment from right to left
    for (int i = n - 1; i >= 0; i--) {
        // Try to increment current character
        if (result[i] < 'a' + k - 1) {
            result[i]++;
            
            // Fill the rest greedily
            for (int j = i + 1; j < n; j++) {
                for (int c = 0; c < k; c++) {
                    char ch = 'a' + c;
                    // Check if this character creates palindrome
                    bool valid = true;
                    if (j > 0 && result[j-1] == ch) {
                        valid = false;
                    }
                    if (j > 1 && result[j-2] == ch) {
                        valid = false;
                    }
                    
                    if (valid) {
                        result[j] = ch;
                        break;
                    }
                }
            }
            
            return result;
        }
    }
    
    result[0] = '\0';
    return result;
}

int main() {
    char s[1000];
    int k;
    scanf("%s %d", s, &k);
    printf("%s\n", smallestBeautifulString(s, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × k)

We visit each position once, and for each position try at most k characters

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for character manipulation

✓ Linear Space

38.4K Views

Medium Frequency

~25 min Avg. Time

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

Optimized Greedy Construction — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler