Construct K Palindrome Strings

Construct K Palindrome Strings - Problem

Given a string s and an integer k, determine whether you can use all the characters in s to construct exactly k non-empty palindrome strings.

A palindrome is a string that reads the same forward and backward. Return true if it's possible to construct k palindromes using all characters from s, otherwise return false.

Key constraints:

You must use all characters from the input string
Each palindrome must be non-empty
You need exactly k palindromes

Input & Output

Example 1 — Basic Case

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

› Output: true

💡 Note: We can construct 2 palindromes: "anna" + "elble" or "anna" + "belle". Only one character 'b' has odd frequency, which is ≤ k=2.

Example 2 — Impossible Case

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

› Output: false

💡 Note: Characters l, t, c, o, d all have odd frequencies (1 each). That's 5 odd frequencies > k=3, so impossible.

Example 3 — Edge Case

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

› Output: true

💡 Note: y appears 7 times, z appears 6 times. Only y has odd frequency, so 1 ≤ 2, possible.

Constraints

1 ≤ k ≤ 10⁵
1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters

Visualization

Tap to expand

Asked in

a Amazon 12 G Google 8

The key insight is that for k palindromes, at most k characters can have odd frequencies. Count character frequencies and check if odd count ≤ k. Best approach is frequency counting. Time: O(n), Space: O(1).

Common Approaches

✓ Bit Manipulation

⏱️ Time: N/A Space: N/A

Brute Force Backtracking

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

Generate all possible ways to partition the string characters into k groups, then verify if each group can form a palindrome. This involves checking every permutation of character assignments.

Frequency Counting

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

Count the frequency of each character. For k palindromes, at most k characters can have odd frequencies (one odd-frequency character per palindrome). If more than k characters have odd frequencies, it's impossible.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

bool solution(const char* s, int k) {
    int n = strlen(s);
    
    // Impossible cases
    if (k > n) {
        return false;
    }
    if (k == n) {
        return true;
    }
    
    // Count character frequencies
    int freq[256] = {0}; // ASCII characters
    for (int i = 0; i < n; i++) {
        freq[(unsigned char)s[i]]++;
    }
    
    // Count characters with odd frequencies
    int oddCount = 0;
    for (int i = 0; i < 256; i++) {
        if (freq[i] % 2 == 1) {
            oddCount++;
        }
    }
    
    // We can have at most k palindromes, so at most k odd-frequency characters
    return oddCount <= k;
}

int main() {
    char s[1001];
    int k;
    
    fgets(s, sizeof(s), stdin);
    // Remove newline if present
    int len = strlen(s);
    if (len > 0 && s[len-1] == '\n') {
        s[len-1] = '\0';
    }
    
    scanf("%d", &k);
    
    bool result = solution(s, k);
    
    if (result) {
        printf("true\n");
    } else {
        printf("false\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

891 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