Smallest Palindromic Rearrangement II

Smallest Palindromic Rearrangement II - Problem

Given a palindromic string s and an integer k, your task is to find the k-th lexicographically smallest palindromic permutation of the characters in s.

Key points:

The input string s is already a palindrome
You need to rearrange its characters to form different palindromes
Return the k-th smallest palindrome in lexicographical order
If there are fewer than k distinct palindromic permutations, return an empty string
Different arrangements that create the same palindromic string count as one permutation

Example: For s = "aab" and k = 2, the palindromic permutations are ["aba", "baa"], so return "baa".

Input & Output

example_1.py — Basic Case

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

› Output: "baa"

💡 Note: The palindromic permutations of "aab" are ["aba", "baa"] in lexicographical order. The 2nd one is "baa".

example_2.py — Single Character

$ Input: s = "aaa", k = 1

› Output: "aaa"

💡 Note: Only one palindromic permutation exists: "aaa". Since k=1, return "aaa".

example_3.py — Impossible Case

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

› Output: ""

💡 Note: "abc" cannot form any palindromic permutation because all characters appear with odd frequency (more than one odd frequency character).

Constraints

1 ≤ s.length ≤ 16
s consists of only lowercase English letters
s is a palindromic string
1 ≤ k ≤ 10⁹
The input string s is guaranteed to be a palindrome

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal approach uses combinatorial mathematics to directly calculate the k-th palindromic permutation. Key insights: palindromes are symmetric (only need to determine first half), use frequency counting and combinatorial ranking to avoid generating all permutations. Time: O(n), Space: O(1).

Common Approaches

✓ Mathematical Combinatorial Approach

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

This approach uses mathematical properties of palindromes and combinatorics to directly compute the k-th lexicographically smallest palindromic permutation. For palindromes, we only need to determine the first half, and the second half follows by symmetry.

Mathematical Combinatorial Approach — Algorithm Steps

Count frequency of each character in the string
Determine the structure: characters that appear odd times go in middle
For each position in first half, calculate how many palindromes start with each possible character
Use this count to determine which character should be at current position for k-th palindrome
Build the palindrome by constructing first half + middle + reverse of first half

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count how many times each character appears

Palindrome Structure

Identify middle character and halve frequencies for symmetric placement

Combinatorial Ranking

For each position, calculate permutations to determine character choice

Build Result

Construct palindrome: first_half + middle + reversed_first_half

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;
}

static char palindromes[40320][20];  // Max 8! permutations for 16 chars
static int palindromeCount = 0;

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

void getPermutations(char* s, int l, int r) {
    if (l == r) {
        if (isPalindrome(s)) {
            // Check if already exists
            for (int i = 0; i < palindromeCount; i++) {
                if (strcmp(palindromes[i], s) == 0) {
                    return;
                }
            }
            strcpy(palindromes[palindromeCount], s);
            palindromeCount++;
        }
        return;
    }
    
    for (int i = l; i <= r; i++) {
        swap(&s[l], &s[i]);
        getPermutations(s, l + 1, r);
        swap(&s[l], &s[i]); // backtrack
    }
}

int compare(const void* a, const void* b) {
    return strcmp((char*)a, (char*)b);
}

char* solution(char* s, int k) {
    int len = strlen(s);
    int freq[26] = {0};
    
    // Count frequencies
    for (int i = 0; i < len; i++) {
        freq[s[i] - 'a']++;
    }
    
    // Check palindrome possibility
    int oddCount = 0;
    for (int i = 0; i < 26; i++) {
        if (freq[i] % 2 == 1) oddCount++;
    }
    if (oddCount > 1) {
        char* empty = malloc(1);
        empty[0] = '\0';
        return empty;
    }
    
    // Reset global variables
    palindromeCount = 0;
    
    // Generate all palindromic permutations
    char temp[20];
    strcpy(temp, s);
    getPermutations(temp, 0, len - 1);
    
    // Sort palindromes
    qsort(palindromes, palindromeCount, sizeof(palindromes[0]), compare);
    
    // Return k-th palindrome (1-indexed)
    if (k <= palindromeCount) {
        char* result = malloc(len + 1);
        strcpy(result, palindromes[k-1]);
        return result;
    } else {
        char* empty = malloc(1);
        empty[0] = '\0';
        return empty;
    }
}

int main() {
    char s[20];
    int k;
    
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = '\0';  // Remove newline
    
    scanf("%d", &k);
    
    // Remove quotes if present
    if (s[0] == '"') {
        int len = strlen(s);
        memmove(s, s+1, len-1);
        s[len-2] = '\0';
    }
    
    printf("%s\n", solution(s, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count frequencies, O(n/2) to build first half of palindrome

✓ Linear Growth

Space Complexity

O(1)

Only need frequency counter for 26 possible characters

✓ Linear Space

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Mathematical Combinatorial Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler