Maximum Palindromes After Operations

Maximum Palindromes After Operations - Problem

Array Hash Table String Greedy Sorting Counting Medium

You are given a 0-indexed string array words having length n and containing 0-indexed strings.

You are allowed to perform the following operation any number of times (including zero):

Choose integers i, j, x, and y such that 0 <= i, j < n, 0 <= x < words[i].length, 0 <= y < words[j].length, and swap the characters words[i][x] and words[j][y].

Return an integer denoting the maximum number of palindromes words can contain, after performing some operations.

Note: i and j may be equal during an operation.

Input & Output

Example 1 — Basic Case

$ Input: words = ["abc","car","a"]

› Output: 3

💡 Note: We have characters: a,b,c,c,a,r,a → {a:3, b:1, c:2, r:1}. Pairs=2, odds=3. Words sorted by length: [3,3,1]. All three words can be formed: first two length-3 words each need 1 pair + 1 odd character, and the length-1 word needs 1 odd character. Total: 3 palindromes.

Example 2 — All Same Length

$ Input: words = ["ab","ty","yt"]

› Output: 2

💡 Note: Characters: a,b,t,y,y,t → {a:1, b:1, t:2, y:2}. Pairs=2, odds=2. Each word needs 1 pair. We can form 2 palindromes like "ty" and "yt", but "ab" cannot be formed into palindrome with remaining characters.

Example 3 — Single Character Words

$ Input: words = ["a","b","a"]

› Output: 2

💡 Note: Characters: a,b,a → {a:2, b:1}. Pairs=1, odds=1. All words have length 1 (need 0 pairs each). We can form 2 palindromes using the 2 'a' characters, but 'b' forms the third palindrome too. Total: 3, but wait - we have 2 odds available, so answer is 2.

Constraints

1 ≤ words.length ≤ 10⁵
1 ≤ words[i].length ≤ 10⁵
sum(words[i].length) ≤ 2 × 10⁵
words[i] consists of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12

The key insight is that we can swap any characters freely, so treat all characters as a global pool. Count character frequencies, calculate available pairs, then greedily assign pairs to longest words first. Time: O(n log n), Space: O(1).

Common Approaches

✓ Greedy Character Assignment

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

Count all available characters globally, then sort words by length (longest first) and greedily assign pairs to form palindromes. A palindrome needs pairs of characters for symmetric positions plus optionally one odd character for the center.

Try All Distributions

⏱️ Time: O(k!) Space: O(k)

Try every way to redistribute characters among words and check how many palindromes can be formed. This involves generating all permutations of character assignments.

Greedy Character Assignment — Algorithm Steps

Step 1: Count frequency of all characters across all words
Step 2: Calculate total pairs and odd characters available
Step 3: Sort words by length (descending) and assign pairs greedily

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Characters

Count frequency of all characters globally

Sort by Length

Sort words by length (descending) for greedy assignment

Assign Pairs

Assign pairs to longest words first until exhausted

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_WORD_LEN 100
#define MAX_CHARS 256

int compare_desc(const void *a, const void *b) {
    return (*(int*)b - *(int*)a);
}

int solution(char words[][MAX_WORD_LEN], int wordCount) {
    if (wordCount == 0) {
        return 0;
    }
    
    // Count all characters globally
    int charCount[MAX_CHARS] = {0};
    for (int i = 0; i < wordCount; i++) {
        for (int j = 0; words[i][j] != '\0'; j++) {
            charCount[(unsigned char)words[i][j]]++;
        }
    }
    
    // Calculate pairs and odds
    int pairs = 0;
    int odds = 0;
    for (int i = 0; i < MAX_CHARS; i++) {
        if (charCount[i] > 0) {
            pairs += charCount[i] / 2;
            odds += charCount[i] % 2;
        }
    }
    
    // Sort word lengths in descending order (greedy: try longest first)
    int wordLengths[MAX_WORDS];
    for (int i = 0; i < wordCount; i++) {
        wordLengths[i] = strlen(words[i]);
    }
    qsort(wordLengths, wordCount, sizeof(int), compare_desc);
    
    int palindromes = 0;
    
    for (int i = 0; i < wordCount; i++) {
        int neededPairs = wordLengths[i] / 2;
        int needsOdd = wordLengths[i] % 2;
        
        if (pairs >= neededPairs && odds >= needsOdd) {
            palindromes++;
            pairs -= neededPairs;
            odds -= needsOdd;
            // When we use pairs, we might free up some odds
            odds += neededPairs;
        }
    }
    
    return palindromes;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple JSON array parsing
    char words[MAX_WORDS][MAX_WORD_LEN];
    int wordCount = 0;
    
    char *ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char *token = strtok(ptr, ",]");
        while (token && wordCount < MAX_WORDS) {
            // Remove quotes and spaces
            while (*token == ' ' || *token == '"') token++;
            char *end = token + strlen(token) - 1;
            while (end > token && (*end == ' ' || *end == '"' || *end == ']')) {
                *end = '\0';
                end--;
            }
            if (strlen(token) > 0) {
                strcpy(words[wordCount], token);
                wordCount++;
            }
            token = strtok(NULL, ",]");
        }
    }
    
    int result = solution(words, wordCount);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + k)

Sorting n words plus k total characters for counting

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for character counts (26 letters max)

✓ Linear Space

12.5K Views

Medium Frequency

~25 min Avg. Time

234 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

Greedy Character Assignment — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler