Given a number N(1<=N<=2000)., The task is to find the number strings of size N that can be obtained after using characters from 'a' to 'z' and by processing the given q(1<=q<=200000) queries.
For each query given two integers L, R (0<=L<=R<=N) such that substring [L, R] of the generated string of size N must be a palindrome. The task is to process all queries and generate a string of size N such that the substrings of this string defined by all queries are palindrome.
The answer can be very large. So, output answer modulo 1000000007.
Note: 1-based indexing is considered for the string.
Input : N = 3 query 1: (1, 2) query 2: (2, 3) Output : 26 Explanation : Substring 1 to 2 should be palindrome and substring 2 to 3 should be palindrome. so, all three characters should be same. so, we can obtain 26 such strings. Input : N = 4 query 1: (1, 3) query 2: (2, 4) Output : 676 Explanation : substring 1 to 3 should be palindrome and substring 2 to 4 should be a palindrome. So, a first and third character should be the same and second and the fourth should be the same. So, we can obtain 26*26 such strings.
Approach : An efficient solution is to use union-find algorithm.
- Find the mid-point of each range (query) and if there are many queries having the same mid-point then only retain that query whose length is max, i.e (where r – l is max).
- This would have reduced the number of queries to 2*N at max since there is a 2*N number of mid-points in a string of length N.
- Now for each query do union of element l with r, (l + 1) with (r – 1), (l + 2) with (r – 2) and so on. We do this because the character which would be put on the index l would be the same as the one we put on index r. Extending this logic to all queries we need to maintain disjoint-set data structure. So basically all the elements of one component of disjoint-set should have the same letter on them.
- After processing all the queries, let the number of disjoint-set components be x, then the answer is 26^x
Below is the implementation of the above approach :
# Python3 program to implement above approach
N = 2005
mod = 10**9 + 7
# To store the size of string and
# number of queries
n, q = 0, 0
# To store parent and rank of ith place
par = [0 for i in range(N)]
Rank = [0 for i in range(N)]
# To store maximum interval
m = dict()
# Function for initialization
for i in range(n + 1):
Rank[i], par[i] = 0, i
# Function to find parent
if (par[x] != x):
par[x] = find(par[x])
# Function to make union
def Union(x, y):
xpar = find(x)
ypar = find(y)
if (Rank[xpar] < Rank[ypar]):
par[xpar] = ypar
elif (Rank[xpar] > Rank[ypar]):
par[ypar] = xpar
par[ypar] = xpar
Rank[xpar] += 1
# Power function to calculate a raised to m1
# under modulo 10000007
def power(a, m1):
if (m1 == 0):
elif (m1 == 1):
elif (m1 == 2):
return (a * a) % mod
elif (m1 & 1):
return (a * power(power(a, m1 // 2), 2)) % mod
return power(power(a, m1 // 2), 2) % mod
# Function to take maxmium interval
def query(l, r):
if l + r in m.keys():
m[l + r] = max(m[l + r], r)
m[l + r] = max(0, r)
# Function to find different possible strings
for i in m:
x = i – m[i]
y = m[i]
# make union of all chracters which
# are meant to be same
while (x < y): Union(x, y) x += 1 y -= 1 # find number of different sets formed ans = 0 for i in range(1, n + 1): if (par[i] == i): ans += 1 # return the required answer return power(26, ans) % mod # Driver Code n = 4 # queries query(1, 3) query(2, 4) print(possiblestrings()) # This code is contributed by Mohit Kumar [tabbyending]
- Find all strings formed from characters mapped to digits of a number
- Find the count of numbers that can be formed using digits 3, 4 only and having length at max N.
- Given two numbers as strings, find if one is a power of other
- All possible strings of any length that can be formed from a given string
- Count of strings that can be formed using a, b and c under given constraints
- Print all possible strings of length k that can be formed from a set of n characters
- Count of strings that can be formed from another string using each character at-most once
- Sum of all numbers that can be formed with permutations of n digits
- N digit numbers divisible by 5 formed from the M digits
- Check whether a binary string can be formed by concatenating given N numbers sequentially
- Queries to find distance between two nodes of a Binary tree
- Queries to find maximum product pair in range with updates
- Queries to find distance between two nodes of a Binary tree - O(logn) method
- Find longest palindrome formed by removing or shuffling chars from string
- Find the Largest Cube formed by Deleting minimum Digits from a number
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to firstname.lastname@example.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.
Improved By : mohit kumar 29