Open In App

CSES Solution - Palindrome Queries

Last Updated : 28 Mar, 2024
Comments
Improve
Suggest changes
Like Article
Like
Report

You are given a string that consists of n characters between a–z. The positions of the string are indexed 1,2,...n.

Your task is to process m operations of the following types:

  • Change the character at position k to x
  • Check if the substring from position a to position b is a palindrome

Input: Each operations are in the form of "1 k x" or "2 a b".

Example:

Input: S = aybabtu, m = {{2, 3, 5}, {1, 3, 'x'}, {2, 3, 5}, {1, 5, 'x'}, {2, 3, 5}}
Output:
YES
NO
YES

Input: S = "racecar", m = { {1, 2, 'a'}, {2, 0, 6}, {1, 3, 'e'}, {2, 0, 6}}
Output:
NO
NO

Approach:

The idea is to hash table to store the forward and backward representations of the string. Each character in the string is mapped with a unique prime number (hash), and the representation of a substring is the product of the hashes of its characters. This allows us to compute the representation of any substring in constant time, given the representations of its prefix and suffix.

Lets breakdown step-by-step solution:

We will do Preprocessing: We first compute the powers of a fixed hash for each position in the string, and initialize two hash tables to store the forward and backward representations of the string.

We'll Updating a Character: When the operation is to change a character, we update the forward and backward hash tables at the corresponding position. This is done by multiplying the old hash at the position by the new hash, and updating the hash tables.

Checking a Substring: When the operation is to check if a substring is a palindrome, we query the forward and backward hash tables for the substring, and adjust the hashes by the appropriate powers to align the substring with the start of the string. If the adjusted forward and backward hashes are equal, then the substring is a palindrome.

Performing the Operations: We perform each operation in the order given. For each operation, we either update a character or check a substring as described above.

Step-by-step approach:

  • Create constants HASH and MOD for hashing.
  • Initialize arrays hashPower[], fwdHashTable[], and bckHashTable[] for hashing operations.
  • Implement functions to update and query hash values in the forward and backward hash tables:
    • updatefwd and queryfwd functions for the forward hash table.
    • updatebck and querybck functions for the backward hash table.
  • Our main function:
    • Perform each operation:
    • If the operation type is 1:
      • Update the forward and backward hash tables for a specific position with a new character.
    • If the operation type is 2:
      • Query forward and backward hash tables for a substring defined by left and right positions.
      • Check if the substring is a palindrome by comparing the forward and backward hash values.
      • Output "YES" if it's a palindrome, otherwise output "NO".

Below is the implementation of the above approach:

Java 
import java.util.*;

public class Main {
    // Define HASH and MOD constants
    static final long HASH = 257;
    static final long MOD = 1000000007;

    // Length of the string and number of operations
    static int n, m;

    // Array to store powers of HASH
    static long[] hashPower = new long[200005];

    // Forward hash table
    static long[] fwdHashTable = new long[400005];

    // Backward hash table
    static long[] bckHashTable = new long[400005];

    // Function to update the hash value at position i in the forward hash table
    static void updatefwd(int i, long v) {
        for (fwdHashTable[i += n] = v; i > 1; i >>= 1)
            fwdHashTable[i >> 1] = (fwdHashTable[i] + fwdHashTable[i ^ 1]) % MOD;
    }

    // Function to query the hash value from position l to r in the forward hash table
    static long queryfwd(int l, int r) {
        long res = 0;
        for (l += n, r += n + 1; l < r; l >>= 1, r >>= 1) {
            if ((l & 1) == 1) res = (res + fwdHashTable[l++]) % MOD;
            if ((r & 1) == 1) res = (res + fwdHashTable[--r]) % MOD;
        }
        return res;
    }

    // Function to update the hash value at position i in the backward hash table
    static void updatebck(int i, long v) {
        for (bckHashTable[i += n] = v; i > 1; i >>= 1)
            bckHashTable[i >> 1] = (bckHashTable[i] + bckHashTable[i ^ 1]) % MOD;
    }

    // Function to query the hash value from position l to r in the backward hash table
    static long querybck(int l, int r) {
        long res = 0;
        for (l += n, r += n + 1; l < r; l >>= 1, r >>= 1) {
            if ((l & 1) == 1) res = (res + bckHashTable[l++]) % MOD;
            if ((r & 1) == 1) res = (res + bckHashTable[--r]) % MOD;
        }
        return res;
    }

    public static void main(String[] args) {
        n = 7;
        m = 5;
        String s = "aybabtu";

        // Operations
        List<int[]> operations = Arrays.asList(new int[]{2, 3, 5}, new int[]{1, 3, 'x'}, new int[]{2, 3, 5}, new int[]{1, 5, 'x'}, new int[]{2, 3, 5});

        // Initialize hash powers for hashing
        hashPower[0] = 1;
        for (int i = 1; i < n; i++)
            hashPower[i] = (hashPower[i - 1] * HASH) % MOD;

        // Initialize forward and backward hash tables with the input string
        for (int i = 0; i < n; i++) {
            char c = s.charAt(i);
            updatefwd(i, (hashPower[i] * c) % MOD);
            updatebck(i, (hashPower[n - i - 1] * c) % MOD);
        }

        // Perform each operation
        for (int[] op : operations) {
            int opType = op[0];
            if (opType == 1) { // If operation is type 1
                int position = op[1];
                char newChar = (char)op[2];
                position--;

                // Update forward and backward hash tables for position
                updatefwd(position, (hashPower[position] * newChar) % MOD);
                updatebck(position, (hashPower[n - position - 1] * newChar) % MOD);
            } else if (opType == 2) { // If operation is type 2
                int left = op[1], right = op[2];
                left--; right--;

                // Query forward and backward hash tables for substring
                long fwd = queryfwd(left, right);
                fwd = (fwd * hashPower[n - 1 - right]) % MOD;
                long bck = querybck(left, right);
                bck = (bck * hashPower[left]) % MOD;

                // Check if substring is palindrome
                if (fwd == bck) System.out.println("YES");
                else System.out.println("NO");
            }
        }
    }
}

// This code is Contributed by Ayush Mishra
Python 
# Define HASH and MOD constants
HASH = 257
MOD = 1000000007

# Length of the string and number of operations
n, m = 7, 5

# Array to store powers of HASH
hashPower = [0] * 200005

# Forward hash table
fwdHashTable = [0] * 400005

# Backward hash table
bckHashTable = [0] * 400005

# Function to update the hash value at position i in the forward hash table
def updatefwd(i, v):
    i += n
    fwdHashTable[i] = v
    while i > 1:
        fwdHashTable[i >> 1] = (fwdHashTable[i] + fwdHashTable[i ^ 1]) % MOD
        i >>= 1

# Function to query the hash value from position l to r in the forward hash table
def queryfwd(l, r):
    res = 0
    l += n
    r += n + 1
    while l < r:
        if l & 1 == 1:
            res = (res + fwdHashTable[l]) % MOD
            l += 1
        if r & 1 == 1:
            r -= 1
            res = (res + fwdHashTable[r]) % MOD
        l >>= 1
        r >>= 1
    return res

# Function to update the hash value at position i in the backward hash table
def updatebck(i, v):
    i += n
    bckHashTable[i] = v
    while i > 1:
        bckHashTable[i >> 1] = (bckHashTable[i] + bckHashTable[i ^ 1]) % MOD
        i >>= 1

# Function to query the hash value from position l to r in the backward hash table
def querybck(l, r):
    res = 0
    l += n
    r += n + 1
    while l < r:
        if l & 1 == 1:
            res = (res + bckHashTable[l]) % MOD
            l += 1
        if r & 1 == 1:
            r -= 1
            res = (res + bckHashTable[r]) % MOD
        l >>= 1
        r >>= 1
    return res

n = 7
m = 5
s = "aybabtu"

# Operations
operations = [[2, 3, 5], [1, 3, 'x'], [2, 3, 5], [1, 5, 'x'], [2, 3, 5]]

# Initialize hash powers for hashing
hashPower[0] = 1
for i in range(1, n):
    hashPower[i] = (hashPower[i - 1] * HASH) % MOD

# Initialize forward and backward hash tables with the input string
for i in range(n):
    c = s[i]
    updatefwd(i, (hashPower[i] * ord(c)) % MOD)
    updatebck(i, (hashPower[n - i - 1] * ord(c)) % MOD)

# Perform each operation
for op in operations:
    opType = op[0]
    if opType == 1:  # If operation is type 1
        position, newChar = op[1] - 1, op[2]
        updatefwd(position, (hashPower[position] * ord(newChar)) % MOD)
        updatebck(position, (hashPower[n - position - 1] * ord(newChar)) % MOD)
    elif opType == 2:  # If operation is type 2
        left, right = op[1] - 1, op[2] - 1
        fwd = queryfwd(left, right)
        fwd = (fwd * hashPower[n - 1 - right]) % MOD
        bck = querybck(left, right)
        bck = (bck * hashPower[left]) % MOD
        if fwd == bck:
            print("YES")
        else:
            print("NO")
JavaScript 
// Define HASH and MOD constants
const HASH = 257;
const MOD = 1000000007;

// Length of the string and number of operations
let n = 7;
let m = 5;

// Array to store powers of HASH
let hashPower = new Array(200005).fill(0);

// Forward hash table
let fwdHashTable = new Array(400005).fill(0);

// Backward hash table
let bckHashTable = new Array(400005).fill(0);

// Function to update the hash value at position i in the forward hash table
function updatefwd(i, v) {
    i += n;
    fwdHashTable[i] = v;
    while (i > 1) {
        fwdHashTable[i >> 1] = (fwdHashTable[i] + fwdHashTable[i ^ 1]) % MOD;
        i >>= 1;
    }
}

// Function to query the hash value from position l to r in the forward hash table
function queryfwd(l, r) {
    let res = 0;
    l += n;
    r += n + 1;
    while (l < r) {
        if (l & 1 === 1) {
            res = (res + fwdHashTable[l]) % MOD;
            l += 1;
        }
        if (r & 1 === 1) {
            r -= 1;
            res = (res + fwdHashTable[r]) % MOD;
        }
        l >>= 1;
        r >>= 1;
    }
    return res;
}

// Function to update the hash value at position i in the backward hash table
function updatebck(i, v) {
    i += n;
    bckHashTable[i] = v;
    while (i > 1) {
        bckHashTable[i >> 1] = (bckHashTable[i] + bckHashTable[i ^ 1]) % MOD;
        i >>= 1;
    }
}

// Function to query the hash value from position l to r in the backward hash table
function querybck(l, r) {
    let res = 0;
    l += n;
    r += n + 1;
    while (l < r) {
        if (l & 1 === 1) {
            res = (res + bckHashTable[l]) % MOD;
            l += 1;
        }
        if (r & 1 === 1) {
            r -= 1;
            res = (res + bckHashTable[r]) % MOD;
        }
        l >>= 1;
        r >>= 1;
    }
    return res;
}

n = 7;
m = 5;
let s = "aybabtu";

// Operations
let operations = [[2, 3, 5], [1, 3, 'x'], [2, 3, 5], [1, 5, 'x'], [2, 3, 5]];

// Initialize hash powers for hashing
hashPower[0] = 1;
for (let i = 1; i < n; i++) {
    hashPower[i] = (hashPower[i - 1] * HASH) % MOD;
}

// Initialize forward and backward hash tables with the input string
for (let i = 0; i < n; i++) {
    let c = s.charCodeAt(i);
    updatefwd(i, (hashPower[i] * c) % MOD);
    updatebck(i, (hashPower[n - i - 1] * c) % MOD);
}

// Perform each operation
for (let op of operations) {
    let opType = op[0];
    if (opType === 1) {  // If operation is type 1
        let position = op[1] - 1;
        let newChar = op[2].charCodeAt(0);
        updatefwd(position, (hashPower[position] * newChar) % MOD);
        updatebck(position, (hashPower[n - position - 1] * newChar) % MOD);
    } else if (opType === 2) {  // If operation is type 2
        let left = op[1] - 1;
        let right = op[2] - 1;
        let fwd = queryfwd(left, right);
        fwd = (fwd * hashPower[n - 1 - right]) % MOD;
        let bck = querybck(left, right);
        bck = (bck * hashPower[left]) % MOD;
        if (fwd === bck) {
            console.log("YES");
        } else {
            console.log("NO");
        }
    }
}
C++14 
#include <bits/stdc++.h>
using namespace std;

using ll = long long;
const ll HASH = 257, MOD = 1e9 + 7;

int n, m;
ll hashPower[200005] = {1};
ll fwdHashTable[400005];
ll bckHashTable[400005];

void updatefwd(int i, ll v) {
    for (fwdHashTable[i += n] = v; i > 1; i >>= 1)
        fwdHashTable[i >> 1] = (fwdHashTable[i] + fwdHashTable[i ^ 1]) % MOD;
}

ll queryfwd(int l, int r) {
    ll res = 0;
    for (l += n, r += n + 1; l < r; l >>= 1, r >>= 1) {
        if (l & 1)
            res = (res + fwdHashTable[l++]) % MOD;
        if (r & 1)
            res = (res + fwdHashTable[--r]) % MOD;
    }
    return res;
}

void updatebck(int i, ll v) {
    for (bckHashTable[i += n] = v; i > 1; i >>= 1)
        bckHashTable[i >> 1] = (bckHashTable[i] + bckHashTable[i ^ 1]) % MOD;
}

ll querybck(int l, int r) {
    ll res = 0;
    for (l += n, r += n + 1; l < r; l >>= 1, r >>= 1) {
        if (l & 1)
            res = (res + bckHashTable[l++]) % MOD;
        if (r & 1)
            res = (res + bckHashTable[--r]) % MOD;
    }
    return res;
}

int main() {
    n = 7;
    m = 5;
    string s = "aybabtu";

    vector<vector<int>> operations = {{2, 3, 5},
                                       {1, 3, 'x'},
                                       {2, 3, 5},
                                       {1, 5, 'x'},
                                       {2, 3, 5}};

    for (int i = 1; i < n; i++) {
        hashPower[i] = (hashPower[i - 1] * HASH) % MOD;
    }

    for (int i = 0; i < n; i++) {
        char c = s[i];
        updatefwd(i, hashPower[i] * (ll)c % MOD);
        updatebck(i, hashPower[n - i - 1] * (ll)c % MOD);
    }

    for (auto &op : operations) {
        int opType = op[0];
        if (opType == 1) {
            int position = op[1];
            char newChar = op[2];
            position--;

            updatefwd(position, hashPower[position] * (ll)newChar % MOD);
            updatebck(position, hashPower[n - position - 1] * (ll)newChar % MOD);
        } else if (opType == 2) {
            int left = op[1], right = op[2];
            left--, right--;

            ll fwd = queryfwd(left, right);
            fwd = (fwd * hashPower[n - 1 - right]) % MOD;
            ll bck = querybck(left, right);
            bck = (bck * hashPower[left]) % MOD;

            if (fwd == bck)
                cout << "YES\n";
            else
                cout << "NO\n";
        }
    }

    return 0;
}

Output
YES
NO
YES

Time Complexity: O(n log n)
Auxiliary Space: O(n)


Next Article
CSES Solution - Polygon Area

V
vforvikram
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox