Can Make Palindrome from Substring

Can Make Palindrome from Substring - Problem

Array Hash Table String Bit Manipulation Prefix Sum Medium

You are given a string s and array queries where queries[i] = [left_i, right_i, k_i]. We may rearrange the substring s[left_i...right_i] for each query and then choose up to k_i of them to replace with any lowercase English letter.

If the substring is possible to be a palindrome string after the operations above, the result of the query is true. Otherwise, the result is false.

Return a boolean array answer where answer[i] is the result of the i-th query queries[i].

Note: Each letter is counted individually for replacement, so if s[left_i...right_i] = "aaa" and k_i = 2, we can only replace two of the letters. Also, no query modifies the initial string s.

Input & Output

Example 1 — Multiple Query Types

$ Input: s = "abcda", queries = [[3,3,0],[1,2,0],[0,3,1],[0,3,2],[0,4,1]]

› Output: [true,false,false,true,true]

💡 Note: Query [3,3,0]: substring "d" is already palindrome. Query [1,2,0]: "bc" needs 1 replacement, but k=0. Query [0,3,1]: "abcd" has 4 odd chars, needs 1.5≈2 replacements > k=1. Query [0,3,2]: "abcd" needs 2 replacements ≤ k=2. Query [0,4,1]: "abcda" has 2 odd chars (b,c), needs 0.5≈1 replacement ≤ k=1.

Example 2 — Edge Cases

$ Input: s = "lyb", queries = [[0,1,0],[2,2,1]]

› Output: [false,true]

💡 Note: Query [0,1,0]: "ly" has 2 odd characters, needs 1 replacement but k=0. Query [2,2,1]: "b" is single character, always palindrome.

Example 3 — All Same Characters

$ Input: s = "aaaa", queries = [[0,3,0],[1,2,1]]

› Output: [true,true]

💡 Note: Query [0,3,0]: "aaaa" has all even frequencies, palindrome possible. Query [1,2,1]: "aa" is already palindrome.

Constraints

1 ≤ s.length, queries.length ≤ 10⁵
0 ≤ left_i ≤ right_i < s.length
0 ≤ k_i ≤ s.length
s consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 12

The key insight is that a palindrome can have at most one character with odd frequency. We can use prefix sums or bit manipulation to efficiently count character frequencies in substrings. Best approach uses XOR prefix arrays for O(1) queries. Time: O(n + q), Space: O(n)

Common Approaches

✓ Bit Manipulation Optimization

⏱️ Time: O(n + q) Space: O(n)

Instead of counting frequencies, use a bitmask where each bit represents whether a character has odd frequency. XOR operations toggle bits, and counting set bits gives odd frequency count.

Brute Force

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

For each query, extract the substring, count character frequencies, then check if we can make palindrome with available replacements. A palindrome can have at most one character with odd frequency.

Prefix Sum with Frequency

⏱️ Time: O(n + q) Space: O(26n)

Build prefix frequency arrays for each character to quickly get character counts in any substring. For each query, use prefix sums to get frequencies in O(1) time per character.

Bit Manipulation Optimization — Algorithm Steps

Build prefix XOR arrays for bitmasks
For each query, XOR range to get frequency parity
Count set bits in result bitmask
Check if palindrome possible with k replacements

Visualization

Tap to expand

Step-by-Step Walkthrough

Build XOR Prefix

Each character toggles its bit in cumulative XOR

Range XOR

XOR of range gives frequency parity for each character

Count Set Bits

Number of 1s = characters with odd frequency

Code -

solution.c — C

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

int popCount(int x) {
    int count = 0;
    while (x) {
        count += x & 1;
        x >>= 1;
    }
    return count;
}

void solution(char* s, int queries[][3], int queryCount, int* result) {
    int n = strlen(s);
    // Build prefix XOR array
    int* prefix = (int*)calloc(n + 1, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        int charBit = 1 << (s[i] - 'a');
        prefix[i + 1] = prefix[i] ^ charBit;
    }
    
    for (int i = 0; i < queryCount; i++) {
        int left = queries[i][0];
        int right = queries[i][1];
        int k = queries[i][2];
        
        // Get XOR for range [left, right]
        int xorResult = prefix[right + 1] ^ prefix[left];
        
        // Count set bits (odd frequency characters)
        int oddCount = popCount(xorResult);
        
        // Check if palindrome is possible
        int neededReplacements = (oddCount > 1) ? (oddCount - 1) / 2 : 0;
        result[i] = (neededReplacements <= k);
    }
    
    free(prefix);
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char queriesLine[10000];
    fgets(queriesLine, sizeof(queriesLine), stdin);
    
    int queries[100][3];
    int queryCount = 0;
    
    // Parse queries array
    int len = strlen(queriesLine);
    int i = 0;
    
    // Find first '['
    while (i < len && queriesLine[i] != '[') i++;
    i++; // skip '['
    
    while (i < len && queryCount < 100) {
        // Skip whitespace and commas
        while (i < len && (queriesLine[i] == ' ' || queriesLine[i] == ',')) i++;
        
        if (i >= len || queriesLine[i] == ']') break;
        
        if (queriesLine[i] == '[') {
            i++; // skip '['
            
            // Parse first number
            int num = 0;
            int sign = 1;
            if (queriesLine[i] == '-') {
                sign = -1;
                i++;
            }
            while (i < len && isdigit(queriesLine[i])) {
                num = num * 10 + (queriesLine[i] - '0');
                i++;
            }
            queries[queryCount][0] = sign * num;
            
            // Skip comma
            while (i < len && queriesLine[i] != ',') i++;
            if (i < len) i++;
            
            // Parse second number
            num = 0;
            sign = 1;
            if (queriesLine[i] == '-') {
                sign = -1;
                i++;
            }
            while (i < len && isdigit(queriesLine[i])) {
                num = num * 10 + (queriesLine[i] - '0');
                i++;
            }
            queries[queryCount][1] = sign * num;
            
            // Skip comma
            while (i < len && queriesLine[i] != ',') i++;
            if (i < len) i++;
            
            // Parse third number
            num = 0;
            sign = 1;
            if (queriesLine[i] == '-') {
                sign = -1;
                i++;
            }
            while (i < len && isdigit(queriesLine[i])) {
                num = num * 10 + (queriesLine[i] - '0');
                i++;
            }
            queries[queryCount][2] = sign * num;
            
            // Skip to ']'
            while (i < len && queriesLine[i] != ']') i++;
            if (i < len) i++;
            
            queryCount++;
        } else {
            i++;
        }
    }
    
    int result[100];
    solution(s, queries, queryCount, result);
    
    printf("[");
    for (int i = 0; i < queryCount; i++) {
        printf("%s", result[i] ? "true" : "false");
        if (i < queryCount - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + q)

O(n) to build prefix XOR array, O(1) per query with bit counting

✓ Linear Growth

Space Complexity

O(n)

Single prefix array storing bitmasks

⚡ Linearithmic Space

28.5K Views

Medium Frequency

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

Bit Manipulation Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler