Construct K Palindrome Strings - Practice Coding Problems

Construct K Palindrome Strings - Problem

Imagine you're a word puzzle master tasked with creating k palindrome strings using all the characters from a given string s. A palindrome reads the same forwards and backwards, like "racecar" or "level".

Your challenge is to determine if it's possible to redistribute all characters from the input string to form exactly k non-empty palindromes. Each character must be used exactly once, and you need to create exactly k palindromic strings.

Examples:

With string "annabelle" and k=2, you could form ["anna", "belleb"]
With string "abc" and k=3, you could form ["a", "b", "c"] (single characters are palindromes)
With string "abc" and k=2, it's impossible since we'd need at least one multi-character palindrome, but we only have unique characters

Return true if the redistribution is possible, false otherwise.

Input & Output

example_1.py — Basic Case

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

› Output: true

💡 Note: We can construct 2 palindromes: "anna" (using a,n,n,a) and "belleb" (using b,e,l,l,e,b). Character frequencies: a:2, n:2, b:1, e:2, l:2. Only 'b' has odd frequency (1), and 1 ≤ 2, so it's possible.

example_2.py — Impossible Case

$ Input: s = "leetcode", k = 3

› Output: false

💡 Note: Character frequencies: l:1, e:3, t:1, c:1, o:1, d:1. We have 5 characters with odd frequencies, but k=3. Since each palindrome can have at most 1 odd-frequency character, we need at least 5 palindromes, not 3.

example_3.py — Edge Case - All Singles

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

› Output: true

💡 Note: We can form 3 single-character palindromes: "a", "b", "c". Each character appears once (odd frequency), and we have exactly 3 odd-frequency characters for k=3 palindromes.

Visualization

Tap to expand

Understanding the Visualization

Count Materials

Count how many of each character (building material) we have

Find Unpaired Items

Characters with odd counts are 'unpaired' - they need to go in the center of palindromes

Check Distribution

Since each palindrome can have at most one center piece, we need odd_count ≤ k

Key Takeaway

🎯 Key Insight: Just like each symmetric building can have at most one unique centerpiece, each palindrome can contain at most one character with an odd frequency. The solution elegantly reduces to: count odd-frequency characters and check if ≤ k.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string to count character frequencies

✓ Linear Growth

Space Complexity

O(1)

Only need space for at most 26 character counts (constant space)

✓ Linear Space

Constraints

1 ≤ k ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Each palindrome must be non-empty
All characters from s must be used exactly once

Asked in

a Amazon 35 G Google 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses character frequency counting with the key insight that each palindrome can have at most one character with odd frequency (the middle character). We count characters with odd frequencies and check if this count is ≤ k. Time complexity: O(n), Space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Character Counting (Optimal)	O(n)	O(1)	Count character frequencies and check if odd-frequency characters ≤ k
Brute Force (Generate All Partitions)	O(k^n * n)	O(n)	Generate all possible ways to partition the string into k parts and check if each can form a palindrome

One-Pass Character Counting (Optimal) — Algorithm Steps

Count the frequency of each character in a single pass
Count how many characters have odd frequencies
Check if number of odd-frequency characters ≤ k
Also ensure the string length ≥ k (need at least k characters for k palindromes)

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count how many times each character appears

Identify Odd Counts

Find characters that appear an odd number of times

Apply Rule

Check if odd-count characters ≤ k (palindrome constraint)

Code -

solution.c — C

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

bool canConstruct(char* s, int k) {
    int len = strlen(s);
    
    // Early termination checks
    if (len < k) return false;
    if (len == k) return true;
    
    // Count character frequencies
    int freq[26] = {0};
    for (int i = 0; i < len; i++) {
        freq[s[i] - 'a']++;
    }
    
    // Count characters with odd frequency
    int oddCount = 0;
    for (int i = 0; i < 26; i++) {
        if (freq[i] % 2 == 1) {
            oddCount++;
        }
    }
    
    // Can construct k palindromes if odd_count <= k
    return oddCount <= k;
}

// Example with input parsing
#include <stdio.h>
int main() {
    char s[100001];
    int k;
    scanf("%s %d", s, &k);
    
    if (canConstruct(s, k)) {
        printf("true\n");
    } else {
        printf("false\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string to count character frequencies

✓ Linear Growth

Space Complexity

O(1)

Only need space for at most 26 character counts (constant space)

✓ Linear Space

Constraints

1 ≤ k ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Each palindrome must be non-empty
All characters from s must be used exactly once

52.8K Views

Medium Frequency

~15 min Avg. Time

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

One-Pass Character Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler