Smallest Palindromic Rearrangement I

Smallest Palindromic Rearrangement I - Problem

You are given a palindromic string s. Return the lexicographically smallest palindromic permutation of s.

A palindromic string reads the same forward and backward. A lexicographically smaller string is one that would appear earlier in dictionary order.

Since the input is already a palindrome, we need to find the smallest possible rearrangement that maintains the palindromic property.

Input & Output

Example 1 — Basic Rearrangement

$ Input: s = "aabcc"

› Output: "acbca"

💡 Note: The input "aabcc" can be rearranged to form "acbca" which is a palindrome. This is the lexicographically smallest palindromic permutation possible.

Example 2 — Already Optimal

$ Input: s = "aba"

› Output: "aba"

💡 Note: The string "aba" is already a palindrome and in its lexicographically smallest form, so we return it as is.

Example 3 — Single Character

$ Input: s = "a"

› Output: "a"

💡 Note: A single character is always a palindrome and is already in its smallest form.

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase English letters
s is guaranteed to be a palindrome

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is that to get the lexicographically smallest palindrome, we should sort all characters and place them symmetrically from outside to center. The optimal approach sorts the string and constructs the palindrome in one pass. Time: O(n log n), Space: O(1).

Common Approaches

✓ Brute Force - Generate All Permutations

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

Generate all permutations of the string, check which ones are palindromes, and return the lexicographically smallest one. This is highly inefficient but demonstrates the basic approach.

Frequency Count and Construction

⏱️ Time: O(n log n) Space: O(k)

Count the frequency of each character, then construct the palindrome by placing characters symmetrically. Place half of each character's count on the left, any odd-count character in the middle, and mirror on the right.

Sort and Build Optimally

⏱️ Time: O(n log n) Space: O(1)

Sort all characters first, then build the palindrome by placing characters systematically. This ensures we get the lexicographically smallest result directly without needing to compare multiple possibilities.

Brute Force - Generate All Permutations — Algorithm Steps

Generate all permutations of the string
Filter only palindromic permutations
Return the lexicographically smallest palindrome

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible arrangements

Filter Palindromes

Keep only palindromic strings

Find Smallest

Return lexicographically smallest

Code -

solution.c — C

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

int isPalindrome(char* s) {
    int len = strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) {
            return 0;
        }
    }
    return 1;
}

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

char* smallest = NULL;

void generatePermutations(char* s, int start, int len) {
    if (start == len) {
        if (isPalindrome(s)) {
            if (smallest == NULL || strcmp(s, smallest) < 0) {
                if (smallest) free(smallest);
                smallest = malloc(len + 1);
                strcpy(smallest, s);
            }
        }
        return;
    }
    
    for (int i = start; i < len; i++) {
        swap(&s[start], &s[i]);
        generatePermutations(s, start + 1, len);
        swap(&s[start], &s[i]);
    }
}

char* solution(char* s) {
    int len = strlen(s);
    char* copy = malloc(len + 1);
    strcpy(copy, s);
    
    generatePermutations(copy, 0, len);
    
    char* result = malloc(len + 1);
    strcpy(result, smallest);
    
    free(copy);
    free(smallest);
    smallest = NULL;
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n!×n)

n! permutations, each taking O(n) time to check if palindrome

⚠ Quadratic Growth

Space Complexity

O(n!)

Store all permutations in memory before filtering

⚠ Quadratic Space

12.5K Views

Medium Frequency

~15 min Avg. Time

456 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

Brute Force - Generate All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler