Palindrome Permutation II - Practice Coding Problems

Palindrome Permutation II - Problem

Palindrome Permutation II is a fascinating string manipulation problem that combines permutation generation with palindrome validation.

Given a string s, your task is to return all possible palindromic permutations (without duplicates) of the input string. A palindrome reads the same forwards and backwards, like "aba" or "racecar".

Key Insight: Not all strings can form palindromic permutations! For a string to form a palindrome, at most one character can have an odd frequency (this would be the middle character).

Examples:
• "aab" → ["aba", "baa"]
• "abc" → [] (impossible to form palindrome)
• "aabbcc" → Multiple palindromic arrangements possible

Input & Output

example_1.py — Basic case with possible palindromes

$ Input: s = "aab"

› Output: ["aba", "baa"]

💡 Note: The string "aab" has frequencies: a=2, b=1. Since only one character (b) has odd frequency, palindromes are possible. We can form "aba" and "baa" by arranging the characters appropriately.

example_2.py — Impossible case

$ Input: s = "abc"

› Output: []

💡 Note: The string "abc" has frequencies: a=1, b=1, c=1. Since three characters have odd frequencies (more than 1), it's impossible to form any palindromic permutations.

example_3.py — Multiple palindromes possible

$ Input: s = "aabb"

› Output: ["abba", "baab"]

💡 Note: The string "aabb" has frequencies: a=2, b=2. Since all characters have even frequencies, multiple palindromic arrangements are possible by placing pairs symmetrically.

Visualization

Tap to expand

🎯 Key Insight: By permuting only half the characters and mirroring, we avoid generating non-palindromic strings!

Understanding the Visualization

Count the Books

Count how many of each book type you have. For a mirror arrangement, you need pairs (except maybe one unique book for the center).

Check Feasibility

If you have more than one book type with odd count, a perfect mirror arrangement is impossible.

Arrange Half + Mirror

Place pairs of books symmetrically from outside-in. Any single book goes in the center, then the 'mirror' completes the palindrome.

Generate All Arrangements

Try different arrangements of the first half - each creates a unique palindromic permutation when mirrored.

Key Takeaway

🎯 Key Insight: Instead of generating all permutations and filtering, we build palindromes directly by permuting only half the characters and using the mirror property - this is exponentially more efficient!

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

O(n!) to generate all permutations, O(n) to check each for palindrome property

⚠ Quadratic Growth

Space Complexity

O(n! × n)

Storing all permutations, each of length n

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 16
s consists of only lowercase English letters
Note: The relatively small constraint on length makes backtracking feasible

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses frequency counting followed by smart backtracking. First, count character frequencies to determine if palindromic permutations are possible (at most one odd frequency). Then, use backtracking to generate palindromes by permuting only the first half of characters and mirroring them, with any odd-frequency character placed in the center. This reduces complexity from O(n!) to O(n × (n/2)!).

Common Approaches

Approach	Time	Space	Notes
✓ Generate All Permutations + Filter	O(n! × n)	O(n! × n)	Generate all possible permutations and filter for palindromes
Frequency Count + Backtracking	O(n × n/2!)	O(n)	Count character frequencies first, then generate only valid palindromic permutations

Generate All Permutations + Filter — Algorithm Steps

Generate all permutations of the input string
For each permutation, check if it's a palindrome
Collect all palindromic permutations
Remove duplicates from the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Create every possible arrangement of characters

Check Each

Test each permutation for palindrome property

Filter Results

Keep only the palindromic permutations

Code -

solution.c — C

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

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

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

void permute(char* str, int start, int end, char results[][100], int* count) {
    if (start == end) {
        if (isPalindrome(str)) {
            strcpy(results[*count], str);
            (*count)++;
        }
    } else {
        for (int i = start; i <= end; i++) {
            swap(&str[start], &str[i]);
            permute(str, start + 1, end, results, count);
            swap(&str[start], &str[i]);
        }
    }
}

int main() {
    char input[100];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    char results[1000][100];
    int count = 0;
    
    permute(input, 0, strlen(input) - 1, results, &count);
    
    printf("[");
    for (int i = 0; i < count; i++) {
        printf("\"%s\"", results[i]);
        if (i < count - 1) printf(", ");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

O(n!) to generate all permutations, O(n) to check each for palindrome property

⚠ Quadratic Growth

Space Complexity

O(n! × n)

Storing all permutations, each of length n

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 16
s consists of only lowercase English letters
Note: The relatively small constraint on length makes backtracking feasible

67.2K Views

Medium-High Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Generate All Permutations + Filter — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler