Palindrome Rearrangement Queries

Palindrome Rearrangement Queries - Problem

Imagine you have a string that's like a folded paper - it has two halves that should mirror each other perfectly to form a palindrome. You're given a string s of even length n, and for each query, you can rearrange characters within specific substrings in both halves.

The Challenge: For each query [a, b, c, d], you can:

Rearrange characters in the left half substring s[a:b] (where 0 ≤ a ≤ b < n/2)
Rearrange characters in the right half substring s[c:d] (where n/2 ≤ c ≤ d < n)

Your goal is to determine if these rearrangements can make the entire string a palindrome. Each query is independent - you start fresh each time!

Example: If s = "abcdef" and query is [0,1,4,5], you can rearrange "ab" and "ef" to potentially make the whole string palindromic.

Input & Output

example_1.py — Basic Palindrome Check

$ Input: s = "abcdef", queries = [[0,1,4,5]]

› Output: [False]

💡 Note: We can rearrange 'ab' and 'ef' to get characters 'abef', but the fixed middle characters 'cd' at positions (2,3) don't match, so the string cannot be made palindromic.

example_2.py — Multiple Queries

$ Input: s = "abcdba", queries = [[1,2,4,5]]

› Output: [False]

💡 Note: We can rearrange 'bc' and 'ba' to get characters 'bcba'. For a palindrome, we need pairs of characters, but we have 2 b's, 1 c, and 1 a. Since we have 2 characters with odd frequencies and the total length is even, we cannot form a palindrome.

example_3.py — Impossible Case

$ Input: s = "abcdef", queries = [[0,0,5,5]]

› Output: [False]

💡 Note: We can only rearrange 'a' and 'f', but the middle part 'bcde' cannot form a palindrome with the fixed characters, so it's impossible.

Constraints

n == s.length
2 ≤ n ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
queries[i].length == 4
0 ≤ a_i ≤ b_i < n / 2
n / 2 ≤ c_i ≤ d_i < n
s consists only of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 42 f Meta 38 ⊞ Microsoft 31 a Amazon 27

The key insight is that a palindrome can be formed if and only if at most one character has an odd frequency. We use character frequency counting on the rearrangeable regions while ensuring fixed regions don't violate palindrome constraints. This gives us an O(q * n) time complexity solution that efficiently handles each query independently.

Common Approaches

✓ Brute Force Character Counting

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

This approach counts character frequencies in all regions (modifiable and fixed) and checks if they can form a palindrome. We need to ensure that characters in corresponding positions can match after rearrangement.

Optimized Character Frequency Analysis

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

This optimal approach recognizes that we only need to check if characters in the modifiable regions can be rearranged to form palindromic pairs, while ensuring fixed regions don't violate palindrome constraints.

Brute Force Character Counting — Algorithm Steps

For each query, identify the four regions: left modifiable, left fixed, right fixed, right modifiable
Count character frequencies in each region
Check if modifiable regions can be rearranged to match their palindromic counterparts
Verify that fixed regions already satisfy palindrome constraints

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Regions

Split string into left modifiable, left fixed, right fixed, right modifiable

Count Characters

Count frequency of each character in modifiable regions

Check Fixed Regions

Verify that fixed regions already satisfy palindrome property

Validate Palindrome

Check if character counts can form palindromic arrangement

Code -

solution.c — C

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

bool* canMakePalindrome(char* s, int** queries, int qSize, int* returnSize) {

    int n = strlen(s);
    int half = n / 2;

    *returnSize = qSize;
    bool* ans = malloc(sizeof(bool) * qSize);

    for (int q = 0; q < qSize; q++) {

        int a = queries[q][0];
        int b = queries[q][1];
        int c = queries[q][2];
        int d = queries[q][3];

        int available[26] = {0};
        int needed[26] = {0};

        bool possible = true;

        // Count available characters in modifiable regions
        for (int i = a; i <= b; i++)
            available[s[i] - 'a']++;

        for (int i = c; i <= d; i++)
            available[s[i] - 'a']++;

        for (int i = 0; i < half; i++) {

            int j = n - 1 - i;

            bool leftMod = (i >= a && i <= b);
            bool rightMod = (j >= c && j <= d);

            if (!leftMod && !rightMod) {
                if (s[i] != s[j]) {
                    possible = false;
                    break;
                }
            } else if (!leftMod && rightMod) {
                needed[s[i] - 'a']++;
            } else if (leftMod && !rightMod) {
                needed[s[j] - 'a']++;
            }
            // if both modifiable → we will handle later
        }

        // Check if we have enough available chars
        for (int i = 0; i < 26 && possible; i++) {
            if (needed[i] > available[i]) {
                possible = false;
            }
            available[i] -= needed[i];
        }

        // Remaining chars must form palindrome inside modifiable region
        if (possible) {
            int odd = 0;
            for (int i = 0; i < 26; i++) {
                if (available[i] % 2 != 0)
                    odd++;
            }
            if (odd > 0)
                possible = false;
        }

        ans[q] = possible;
    }

    return ans;
}


int main() {

    char s[100005];
    char line[100005];

    // Read string
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;

    // Read queries
    fgets(line, sizeof(line), stdin);

    int** queries = malloc(sizeof(int*) * 1000);
    int qSize = 0;

    int a, b, c, d;
    char* ptr = line;

    while ((ptr = strchr(ptr, '[')) != NULL) {
        if (sscanf(ptr, "[%d,%d,%d,%d]", &a, &b, &c, &d) == 4) {
            queries[qSize] = malloc(sizeof(int) * 4);
            queries[qSize][0] = a;
            queries[qSize][1] = b;
            queries[qSize][2] = c;
            queries[qSize][3] = d;
            qSize++;
        }
        ptr++; 
    }

    int returnSize;
    bool* result = canMakePalindrome(s, queries, qSize, &returnSize);

    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%s", result[i] ? "true" : "false");
        if (i != returnSize - 1) printf(", ");
    }
    printf("]\n");

    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(q * n)

For each of q queries, we scan up to n characters to count frequencies

✓ Linear Growth

Space Complexity

O(1)

Only need constant space for character frequency counting (26 letters)

✓ Linear Space

31.3K Views

Medium-High Frequency

~25 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

Brute Force Character Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler